blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 7 332 | content_id stringlengths 40 40 | detected_licenses listlengths 0 50 | license_type stringclasses 2 values | repo_name stringlengths 7 115 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 557 values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 5.85k 684M โ | star_events_count int64 0 77.7k | fork_events_count int64 0 48k | gha_license_id stringclasses 17 values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 82 values | src_encoding stringclasses 28 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 7 5.41M | extension stringclasses 11 values | content stringlengths 7 5.41M | authors listlengths 1 1 | author stringlengths 0 161 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d2b8ae785716e990ccd1e5d84b2098868e2b5576 | 104fd74c36067b5acdfc90a8a233527121951b2f | /gfg/array/TrapRainWater.java | 92dfbcaa2bed30c15e6ab8f65d5bc41998f16c9d | [] | no_license | Alhuck/DataStructure | 2be20307b8c4bd5bafac27cd8c1e147c783e3e67 | a326824fe2a3078f74b3a2f7601e092002a7431f | refs/heads/master | 2021-12-27T11:16:24.756997 | 2021-12-26T16:06:30 | 2021-12-26T16:06:30 | 164,541,893 | 2 | 0 | null | 2021-04-24T18:07:15 | 2019-01-08T02:39:11 | Java | UTF-8 | Java | false | false | 886 | java | package gfg.array;
public class TrapRainWater {
public static int getWaterUnitsTrapped(int[] arr) {
int res = 0;
int[] lmax = new int[arr.length];
lmax[0] = arr[0];
for (int i = 1; i < arr.length; i++) {
lmax[i] = Math.max(arr[i], lmax[i - 1]);
}
int[] rmax = new int[arr.length];
rmax[arr.length - 1] = arr[arr.length - 1];
for (int i = arr.length - 2; i >= 0; i--) {
rmax[i] = Math.max(arr[i], rmax[i + 1]);
}
for (int i = 1; i < arr.length - 1; i++) {
res = res + (Math.min(lmax[i], rmax[i]) - arr[i]);
}
return res;
}
public static void main(String[] args) {
// int[] arr = { 3, 0, 1, 2, 5 };
int[] arr = { 2, 0 ,2 };
System.out.println("Trapped water in units: " + getWaterUnitsTrapped(arr));
}
}
| [
"alhucka@gmail.com"
] | alhucka@gmail.com |
92fa0f30846d55eedea22964938f0de73514641b | 0721305fd9b1c643a7687b6382dccc56a82a2dad | /src/app.zenly.locator_4.8.0_base_source_from_JADX/sources/kotlin/collections/C12852r.java | 8a15b17a81d1aac9387981ef63b39daa05721d04 | [] | no_license | a2en/Zenly_re | 09c635ad886c8285f70a8292ae4f74167a4ad620 | f87af0c2dd0bc14fd772c69d5bc70cd8aa727516 | refs/heads/master | 2020-12-13T17:07:11.442473 | 2020-01-17T04:32:44 | 2020-01-17T04:32:44 | 234,470,083 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 104 | java | package kotlin.collections;
/* renamed from: kotlin.collections.r */
class C12852r extends C12851q {
}
| [
"developer@appzoc.com"
] | developer@appzoc.com |
491d551190fc628dac8e8e8792422f559a5b6657 | daab099e44da619b97a7a6009e9dee0d507930f3 | /rt/sun/font/ExtendedTextSourceLabel.java | ab6e958c010e7e2becece66d62b5e7afb62442d3 | [] | no_license | xknower/source-code-jdk-8u211 | 01c233d4f498d6a61af9b4c34dc26bb0963d6ce1 | 208b3b26625f62ff0d1ff6ee7c2b7ee91f6c9063 | refs/heads/master | 2022-12-28T17:08:25.751594 | 2020-10-09T03:24:14 | 2020-10-09T03:24:14 | 278,289,426 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 33,202 | java | /* */ package sun.font;
/* */
/* */ import java.awt.Font;
/* */ import java.awt.Graphics2D;
/* */ import java.awt.Rectangle;
/* */ import java.awt.Shape;
/* */ import java.awt.font.FontRenderContext;
/* */ import java.awt.font.GlyphJustificationInfo;
/* */ import java.awt.font.LineMetrics;
/* */ import java.awt.font.TextAttribute;
/* */ import java.awt.geom.AffineTransform;
/* */ import java.awt.geom.Rectangle2D;
/* */ import java.util.Map;
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ class ExtendedTextSourceLabel
/* */ extends ExtendedTextLabel
/* */ implements Decoration.Label
/* */ {
/* */ TextSource source;
/* */ private Decoration decorator;
/* */ private Font font;
/* */ private AffineTransform baseTX;
/* */ private CoreMetrics cm;
/* */ Rectangle2D lb;
/* */ Rectangle2D ab;
/* */ Rectangle2D vb;
/* */ Rectangle2D ib;
/* */ StandardGlyphVector gv;
/* */ float[] charinfo;
/* */ private static final int posx = 0;
/* */ private static final int posy = 1;
/* */ private static final int advx = 2;
/* */ private static final int advy = 3;
/* */ private static final int visx = 4;
/* */ private static final int visy = 5;
/* */ private static final int visw = 6;
/* */ private static final int vish = 7;
/* */ private static final int numvals = 8;
/* */
/* */ public ExtendedTextSourceLabel(TextSource paramTextSource, Decoration paramDecoration) {
/* 78 */ this.source = paramTextSource;
/* 79 */ this.decorator = paramDecoration;
/* 80 */ finishInit();
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public ExtendedTextSourceLabel(TextSource paramTextSource, ExtendedTextSourceLabel paramExtendedTextSourceLabel, int paramInt) {
/* 90 */ this.source = paramTextSource;
/* 91 */ this.decorator = paramExtendedTextSourceLabel.decorator;
/* 92 */ finishInit();
/* */ }
/* */
/* */ private void finishInit() {
/* 96 */ this.font = this.source.getFont();
/* */
/* 98 */ Map<TextAttribute, ?> map = this.font.getAttributes();
/* 99 */ this.baseTX = AttributeValues.getBaselineTransform(map);
/* 100 */ if (this.baseTX == null) {
/* 101 */ this.cm = this.source.getCoreMetrics();
/* */ } else {
/* 103 */ AffineTransform affineTransform = AttributeValues.getCharTransform(map);
/* 104 */ if (affineTransform == null) {
/* 105 */ affineTransform = new AffineTransform();
/* */ }
/* 107 */ this.font = this.font.deriveFont(affineTransform);
/* */
/* 109 */ LineMetrics lineMetrics = this.font.getLineMetrics(this.source.getChars(), this.source.getStart(), this.source
/* 110 */ .getStart() + this.source.getLength(), this.source.getFRC());
/* 111 */ this.cm = CoreMetrics.get(lineMetrics);
/* */ }
/* */ }
/* */
/* */
/* */
/* */
/* */ public Rectangle2D getLogicalBounds() {
/* 119 */ return getLogicalBounds(0.0F, 0.0F);
/* */ }
/* */
/* */ public Rectangle2D getLogicalBounds(float paramFloat1, float paramFloat2) {
/* 123 */ if (this.lb == null) {
/* 124 */ this.lb = createLogicalBounds();
/* */ }
/* 126 */ return new Rectangle2D.Float((float)(this.lb.getX() + paramFloat1),
/* 127 */ (float)(this.lb.getY() + paramFloat2),
/* 128 */ (float)this.lb.getWidth(),
/* 129 */ (float)this.lb.getHeight());
/* */ }
/* */
/* */ public float getAdvance() {
/* 133 */ if (this.lb == null) {
/* 134 */ this.lb = createLogicalBounds();
/* */ }
/* 136 */ return (float)this.lb.getWidth();
/* */ }
/* */
/* */ public Rectangle2D getVisualBounds(float paramFloat1, float paramFloat2) {
/* 140 */ if (this.vb == null) {
/* 141 */ this.vb = this.decorator.getVisualBounds(this);
/* */ }
/* 143 */ return new Rectangle2D.Float((float)(this.vb.getX() + paramFloat1),
/* 144 */ (float)(this.vb.getY() + paramFloat2),
/* 145 */ (float)this.vb.getWidth(),
/* 146 */ (float)this.vb.getHeight());
/* */ }
/* */
/* */ public Rectangle2D getAlignBounds(float paramFloat1, float paramFloat2) {
/* 150 */ if (this.ab == null) {
/* 151 */ this.ab = createAlignBounds();
/* */ }
/* 153 */ return new Rectangle2D.Float((float)(this.ab.getX() + paramFloat1),
/* 154 */ (float)(this.ab.getY() + paramFloat2),
/* 155 */ (float)this.ab.getWidth(),
/* 156 */ (float)this.ab.getHeight());
/* */ }
/* */
/* */
/* */ public Rectangle2D getItalicBounds(float paramFloat1, float paramFloat2) {
/* 161 */ if (this.ib == null) {
/* 162 */ this.ib = createItalicBounds();
/* */ }
/* 164 */ return new Rectangle2D.Float((float)(this.ib.getX() + paramFloat1),
/* 165 */ (float)(this.ib.getY() + paramFloat2),
/* 166 */ (float)this.ib.getWidth(),
/* 167 */ (float)this.ib.getHeight());
/* */ }
/* */
/* */
/* */ public Rectangle getPixelBounds(FontRenderContext paramFontRenderContext, float paramFloat1, float paramFloat2) {
/* 172 */ return getGV().getPixelBounds(paramFontRenderContext, paramFloat1, paramFloat2);
/* */ }
/* */
/* */ public boolean isSimple() {
/* 176 */ return (this.decorator == Decoration.getPlainDecoration() && this.baseTX == null);
/* */ }
/* */
/* */
/* */ public AffineTransform getBaselineTransform() {
/* 181 */ return this.baseTX;
/* */ }
/* */
/* */ public Shape handleGetOutline(float paramFloat1, float paramFloat2) {
/* 185 */ return getGV().getOutline(paramFloat1, paramFloat2);
/* */ }
/* */
/* */ public Shape getOutline(float paramFloat1, float paramFloat2) {
/* 189 */ return this.decorator.getOutline(this, paramFloat1, paramFloat2);
/* */ }
/* */
/* */ public void handleDraw(Graphics2D paramGraphics2D, float paramFloat1, float paramFloat2) {
/* 193 */ paramGraphics2D.drawGlyphVector(getGV(), paramFloat1, paramFloat2);
/* */ }
/* */
/* */ public void draw(Graphics2D paramGraphics2D, float paramFloat1, float paramFloat2) {
/* 197 */ this.decorator.drawTextAndDecorations(this, paramGraphics2D, paramFloat1, paramFloat2);
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ protected Rectangle2D createLogicalBounds() {
/* 225 */ return getGV().getLogicalBounds();
/* */ }
/* */
/* */ public Rectangle2D handleGetVisualBounds() {
/* 229 */ return getGV().getVisualBounds();
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ protected Rectangle2D createAlignBounds() {
/* 243 */ float[] arrayOfFloat = getCharinfo();
/* */
/* 245 */ float f1 = 0.0F;
/* 246 */ float f2 = -this.cm.ascent;
/* 247 */ float f3 = 0.0F;
/* 248 */ float f4 = this.cm.ascent + this.cm.descent;
/* */
/* 250 */ if (this.charinfo == null || this.charinfo.length == 0) {
/* 251 */ return new Rectangle2D.Float(f1, f2, f3, f4);
/* */ }
/* */
/* 254 */ boolean bool = ((this.source.getLayoutFlags() & 0x8) == 0) ? true : false;
/* 255 */ int i = arrayOfFloat.length - 8;
/* 256 */ if (bool) {
/* 257 */ while (i > 0 && arrayOfFloat[i + 6] == 0.0F) {
/* 258 */ i -= 8;
/* */ }
/* */ }
/* */
/* 262 */ if (i >= 0) {
/* 263 */ byte b = 0;
/* 264 */ while (b < i && (arrayOfFloat[b + 2] == 0.0F || (!bool && arrayOfFloat[b + 6] == 0.0F))) {
/* 265 */ b += 8;
/* */ }
/* */
/* 268 */ f1 = Math.max(0.0F, arrayOfFloat[b + 0]);
/* 269 */ f3 = arrayOfFloat[i + 0] + arrayOfFloat[i + 2] - f1;
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 290 */ return new Rectangle2D.Float(f1, f2, f3, f4);
/* */ }
/* */
/* */ public Rectangle2D createItalicBounds() {
/* 294 */ float f1 = this.cm.italicAngle;
/* */
/* 296 */ Rectangle2D rectangle2D = getLogicalBounds();
/* 297 */ float f2 = (float)rectangle2D.getMinX();
/* 298 */ float f3 = -this.cm.ascent;
/* 299 */ float f4 = (float)rectangle2D.getMaxX();
/* 300 */ float f5 = this.cm.descent;
/* 301 */ if (f1 != 0.0F) {
/* 302 */ if (f1 > 0.0F) {
/* 303 */ f2 -= f1 * (f5 - this.cm.ssOffset);
/* 304 */ f4 -= f1 * (f3 - this.cm.ssOffset);
/* */ } else {
/* 306 */ f2 -= f1 * (f3 - this.cm.ssOffset);
/* 307 */ f4 -= f1 * (f5 - this.cm.ssOffset);
/* */ }
/* */ }
/* 310 */ return new Rectangle2D.Float(f2, f3, f4 - f2, f5 - f3);
/* */ }
/* */
/* */ private final StandardGlyphVector getGV() {
/* 314 */ if (this.gv == null) {
/* 315 */ this.gv = createGV();
/* */ }
/* */
/* 318 */ return this.gv;
/* */ }
/* */
/* */ protected StandardGlyphVector createGV() {
/* 322 */ FontRenderContext fontRenderContext = this.source.getFRC();
/* 323 */ int i = this.source.getLayoutFlags();
/* 324 */ char[] arrayOfChar = this.source.getChars();
/* 325 */ int j = this.source.getStart();
/* 326 */ int k = this.source.getLength();
/* */
/* 328 */ GlyphLayout glyphLayout = GlyphLayout.get(null);
/* 329 */ this.gv = glyphLayout.layout(this.font, fontRenderContext, arrayOfChar, j, k, i, null);
/* 330 */ GlyphLayout.done(glyphLayout);
/* */
/* 332 */ return this.gv;
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public int getNumCharacters() {
/* 348 */ return this.source.getLength();
/* */ }
/* */
/* */ public CoreMetrics getCoreMetrics() {
/* 352 */ return this.cm;
/* */ }
/* */
/* */ public float getCharX(int paramInt) {
/* 356 */ validate(paramInt);
/* 357 */ float[] arrayOfFloat = getCharinfo();
/* 358 */ int i = l2v(paramInt) * 8 + 0;
/* 359 */ if (arrayOfFloat == null || i >= arrayOfFloat.length) {
/* 360 */ return 0.0F;
/* */ }
/* 362 */ return arrayOfFloat[i];
/* */ }
/* */
/* */
/* */ public float getCharY(int paramInt) {
/* 367 */ validate(paramInt);
/* 368 */ float[] arrayOfFloat = getCharinfo();
/* 369 */ int i = l2v(paramInt) * 8 + 1;
/* 370 */ if (arrayOfFloat == null || i >= arrayOfFloat.length) {
/* 371 */ return 0.0F;
/* */ }
/* 373 */ return arrayOfFloat[i];
/* */ }
/* */
/* */
/* */ public float getCharAdvance(int paramInt) {
/* 378 */ validate(paramInt);
/* 379 */ float[] arrayOfFloat = getCharinfo();
/* 380 */ int i = l2v(paramInt) * 8 + 2;
/* 381 */ if (arrayOfFloat == null || i >= arrayOfFloat.length) {
/* 382 */ return 0.0F;
/* */ }
/* 384 */ return arrayOfFloat[i];
/* */ }
/* */
/* */
/* */ public Rectangle2D handleGetCharVisualBounds(int paramInt) {
/* 389 */ validate(paramInt);
/* 390 */ float[] arrayOfFloat = getCharinfo();
/* 391 */ paramInt = l2v(paramInt) * 8;
/* 392 */ if (arrayOfFloat == null || paramInt + 7 >= arrayOfFloat.length) {
/* 393 */ return new Rectangle2D.Float();
/* */ }
/* 395 */ return new Rectangle2D.Float(arrayOfFloat[paramInt + 4], arrayOfFloat[paramInt + 5], arrayOfFloat[paramInt + 6], arrayOfFloat[paramInt + 7]);
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public Rectangle2D getCharVisualBounds(int paramInt, float paramFloat1, float paramFloat2) {
/* 404 */ Rectangle2D rectangle2D = this.decorator.getCharVisualBounds(this, paramInt);
/* 405 */ if (paramFloat1 != 0.0F || paramFloat2 != 0.0F) {
/* 406 */ rectangle2D.setRect(rectangle2D.getX() + paramFloat1, rectangle2D
/* 407 */ .getY() + paramFloat2, rectangle2D
/* 408 */ .getWidth(), rectangle2D
/* 409 */ .getHeight());
/* */ }
/* 411 */ return rectangle2D;
/* */ }
/* */
/* */ private void validate(int paramInt) {
/* 415 */ if (paramInt < 0)
/* 416 */ throw new IllegalArgumentException("index " + paramInt + " < 0");
/* 417 */ if (paramInt >= this.source.getLength()) {
/* 418 */ throw new IllegalArgumentException("index " + paramInt + " < " + this.source.getLength());
/* */ }
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public int logicalToVisual(int paramInt) {
/* 470 */ validate(paramInt);
/* 471 */ return l2v(paramInt);
/* */ }
/* */
/* */ public int visualToLogical(int paramInt) {
/* 475 */ validate(paramInt);
/* 476 */ return v2l(paramInt);
/* */ }
/* */
/* */ public int getLineBreakIndex(int paramInt, float paramFloat) {
/* 480 */ float[] arrayOfFloat = getCharinfo();
/* 481 */ int i = this.source.getLength();
/* 482 */ paramInt--;
/* 483 */ while (paramFloat >= 0.0F && ++paramInt < i) {
/* 484 */ int j = l2v(paramInt) * 8 + 2;
/* 485 */ if (j >= arrayOfFloat.length) {
/* */ break;
/* */ }
/* 488 */ float f = arrayOfFloat[j];
/* 489 */ paramFloat -= f;
/* */ }
/* */
/* 492 */ return paramInt;
/* */ }
/* */
/* */ public float getAdvanceBetween(int paramInt1, int paramInt2) {
/* 496 */ float f = 0.0F;
/* */
/* 498 */ float[] arrayOfFloat = getCharinfo();
/* 499 */ paramInt1--;
/* 500 */ while (++paramInt1 < paramInt2) {
/* 501 */ int i = l2v(paramInt1) * 8 + 2;
/* 502 */ if (i >= arrayOfFloat.length) {
/* */ break;
/* */ }
/* 505 */ f += arrayOfFloat[i];
/* */ }
/* */
/* 508 */ return f;
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public boolean caretAtOffsetIsValid(int paramInt) {
/* 520 */ if (paramInt == 0 || paramInt == this.source.getLength()) {
/* 521 */ return true;
/* */ }
/* 523 */ char c = this.source.getChars()[this.source.getStart() + paramInt];
/* 524 */ if (c == '\t' || c == '\n' || c == '\r') {
/* 525 */ return true;
/* */ }
/* 527 */ int i = l2v(paramInt);
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 537 */ int j = i * 8 + 2;
/* 538 */ float[] arrayOfFloat = getCharinfo();
/* 539 */ if (arrayOfFloat == null || j >= arrayOfFloat.length) {
/* 540 */ return false;
/* */ }
/* 542 */ return (arrayOfFloat[j] != 0.0F);
/* */ }
/* */
/* */
/* */ private final float[] getCharinfo() {
/* 547 */ if (this.charinfo == null) {
/* 548 */ this.charinfo = createCharinfo();
/* */ }
/* 550 */ return this.charinfo;
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ protected float[] createCharinfo() {
/* 619 */ StandardGlyphVector standardGlyphVector = getGV();
/* 620 */ float[] arrayOfFloat = null;
/* */ try {
/* 622 */ arrayOfFloat = standardGlyphVector.getGlyphInfo();
/* */ }
/* 624 */ catch (Exception exception) {
/* 625 */ System.out.println(this.source);
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 634 */ int i = standardGlyphVector.getNumGlyphs();
/* 635 */ if (i == 0) {
/* 636 */ return arrayOfFloat;
/* */ }
/* 638 */ int[] arrayOfInt = standardGlyphVector.getGlyphCharIndices(0, i, null);
/* */
/* 640 */ boolean bool1 = false;
/* 641 */ if (bool1) {
/* 642 */ System.err.println("number of glyphs: " + i);
/* 643 */ for (byte b = 0; b < i; b++) {
/* 644 */ System.err.println("g: " + b + ", x: " + arrayOfFloat[b * 8 + 0] + ", a: " + arrayOfFloat[b * 8 + 2] + ", n: " + arrayOfInt[b]);
/* */ }
/* */ }
/* */
/* */
/* */
/* */
/* 651 */ int j = arrayOfInt[0];
/* 652 */ int k = j;
/* 653 */ int m = 0;
/* 654 */ int n = 0;
/* 655 */ int i1 = 0;
/* 656 */ int i2 = 0;
/* 657 */ int i3 = 0;
/* 658 */ int i4 = i;
/* 659 */ byte b1 = 8;
/* 660 */ byte b2 = 1;
/* */
/* 662 */ boolean bool2 = ((this.source.getLayoutFlags() & 0x1) == 0) ? true : false;
/* 663 */ if (!bool2) {
/* 664 */ j = arrayOfInt[i - 1];
/* 665 */ k = j;
/* 666 */ m = 0;
/* 667 */ n = arrayOfFloat.length - 8;
/* 668 */ i1 = 0;
/* 669 */ i2 = arrayOfFloat.length - 8;
/* 670 */ i3 = i - 1;
/* 671 */ i4 = -1;
/* 672 */ b1 = -8;
/* 673 */ b2 = -1;
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 693 */ float f1 = 0.0F, f2 = 0.0F, f3 = 0.0F, f4 = 0.0F, f5 = 0.0F, f6 = 0.0F;
/* 694 */ float f7 = 0.0F;
/* */
/* */
/* 697 */ boolean bool3 = false;
/* */
/* 699 */ while (i3 != i4) {
/* */
/* 701 */ boolean bool = false;
/* 702 */ byte b = 0;
/* */
/* 704 */ j = arrayOfInt[i3];
/* 705 */ k = j;
/* */
/* */
/* 708 */ i3 += b2;
/* 709 */ i2 += b1;
/* */
/* */
/* */
/* */
/* */
/* 715 */ while (i3 != i4 && (arrayOfFloat[i2 + 2] == 0.0F || j != m || arrayOfInt[i3] <= k || k - j > b)) {
/* */
/* */
/* */
/* */
/* */
/* 721 */ if (!bool) {
/* 722 */ int i5 = i2 - b1;
/* */
/* 724 */ f1 = arrayOfFloat[i5 + 0];
/* 725 */ f2 = f1 + arrayOfFloat[i5 + 2];
/* 726 */ f3 = arrayOfFloat[i5 + 4];
/* 727 */ f4 = arrayOfFloat[i5 + 5];
/* 728 */ f5 = f3 + arrayOfFloat[i5 + 6];
/* 729 */ f6 = f4 + arrayOfFloat[i5 + 7];
/* */
/* 731 */ bool = true;
/* */ }
/* */
/* */
/* 735 */ b++;
/* */
/* */
/* 738 */ float f8 = arrayOfFloat[i2 + 2];
/* 739 */ if (f8 != 0.0F) {
/* 740 */ float f = arrayOfFloat[i2 + 0];
/* 741 */ f1 = Math.min(f1, f);
/* 742 */ f2 = Math.max(f2, f + f8);
/* */ }
/* */
/* */
/* 746 */ float f9 = arrayOfFloat[i2 + 6];
/* 747 */ if (f9 != 0.0F) {
/* 748 */ float f10 = arrayOfFloat[i2 + 4];
/* 749 */ float f11 = arrayOfFloat[i2 + 5];
/* 750 */ f3 = Math.min(f3, f10);
/* 751 */ f4 = Math.min(f4, f11);
/* 752 */ f5 = Math.max(f5, f10 + f9);
/* 753 */ f6 = Math.max(f6, f11 + arrayOfFloat[i2 + 7]);
/* */ }
/* */
/* */
/* 757 */ j = Math.min(j, arrayOfInt[i3]);
/* 758 */ k = Math.max(k, arrayOfInt[i3]);
/* */
/* */
/* 761 */ i3 += b2;
/* 762 */ i2 += b1;
/* */ }
/* */
/* */
/* 766 */ if (bool1) {
/* 767 */ System.out.println("minIndex = " + j + ", maxIndex = " + k);
/* */ }
/* */
/* 770 */ m = k + 1;
/* */
/* */
/* 773 */ arrayOfFloat[n + 1] = f7;
/* 774 */ arrayOfFloat[n + 3] = 0.0F;
/* */
/* 776 */ if (bool) {
/* */
/* 778 */ arrayOfFloat[n + 0] = f1;
/* 779 */ arrayOfFloat[n + 2] = f2 - f1;
/* 780 */ arrayOfFloat[n + 4] = f3;
/* 781 */ arrayOfFloat[n + 5] = f4;
/* 782 */ arrayOfFloat[n + 6] = f5 - f3;
/* 783 */ arrayOfFloat[n + 7] = f6 - f4;
/* */
/* */
/* */
/* */
/* 788 */ if (k - j < b) {
/* 789 */ bool3 = true;
/* */ }
/* */
/* */
/* */
/* */
/* 795 */ if (j < k) {
/* 796 */ if (!bool2)
/* */ {
/* 798 */ f2 = f1;
/* */ }
/* 800 */ f5 -= f3;
/* 801 */ f6 -= f4;
/* */
/* 803 */ int i5 = j, i6 = n / 8;
/* */
/* 805 */ while (j < k) {
/* 806 */ j++;
/* 807 */ i1 += b2;
/* 808 */ n += b1;
/* */
/* 810 */ if ((n < 0 || n >= arrayOfFloat.length) &&
/* 811 */ bool1) System.out.println("minIndex = " + i5 + ", maxIndex = " + k + ", cp = " + i6);
/* */
/* */
/* 814 */ arrayOfFloat[n + 0] = f2;
/* 815 */ arrayOfFloat[n + 1] = f7;
/* 816 */ arrayOfFloat[n + 2] = 0.0F;
/* 817 */ arrayOfFloat[n + 3] = 0.0F;
/* 818 */ arrayOfFloat[n + 4] = f3;
/* 819 */ arrayOfFloat[n + 5] = f4;
/* 820 */ arrayOfFloat[n + 6] = f5;
/* 821 */ arrayOfFloat[n + 7] = f6;
/* */ }
/* */ }
/* */
/* */
/* 826 */ bool = false;
/* 827 */ } else if (bool3) {
/* */
/* 829 */ int i5 = i2 - b1;
/* */
/* 831 */ arrayOfFloat[n + 0] = arrayOfFloat[i5 + 0];
/* 832 */ arrayOfFloat[n + 2] = arrayOfFloat[i5 + 2];
/* 833 */ arrayOfFloat[n + 4] = arrayOfFloat[i5 + 4];
/* 834 */ arrayOfFloat[n + 5] = arrayOfFloat[i5 + 5];
/* 835 */ arrayOfFloat[n + 6] = arrayOfFloat[i5 + 6];
/* 836 */ arrayOfFloat[n + 7] = arrayOfFloat[i5 + 7];
/* */ }
/* */
/* */
/* */
/* 841 */ n += b1;
/* 842 */ i1 += b2;
/* */ }
/* */
/* 845 */ if (bool3 && !bool2) {
/* */
/* */
/* 848 */ n -= b1;
/* 849 */ System.arraycopy(arrayOfFloat, n, arrayOfFloat, 0, arrayOfFloat.length - n);
/* */ }
/* */
/* 852 */ if (bool1) {
/* 853 */ char[] arrayOfChar = this.source.getChars();
/* 854 */ int i5 = this.source.getStart();
/* 855 */ int i6 = this.source.getLength();
/* 856 */ System.out.println("char info for " + i6 + " characters");
/* 857 */ for (byte b = 0; b < i6 * 8;) {
/* 858 */ System.out.println(" ch: " + Integer.toHexString(arrayOfChar[i5 + v2l(b / 8)]) + " x: " + arrayOfFloat[b++] + " y: " + arrayOfFloat[b++] + " xa: " + arrayOfFloat[b++] + " ya: " + arrayOfFloat[b++] + " l: " + arrayOfFloat[b++] + " t: " + arrayOfFloat[b++] + " w: " + arrayOfFloat[b++] + " h: " + arrayOfFloat[b++]);
/* */ }
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 870 */ return arrayOfFloat;
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */ protected int l2v(int paramInt) {
/* 879 */ return ((this.source.getLayoutFlags() & 0x1) == 0) ? paramInt : (this.source.getLength() - 1 - paramInt);
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */ protected int v2l(int paramInt) {
/* 888 */ return ((this.source.getLayoutFlags() & 0x1) == 0) ? paramInt : (this.source.getLength() - 1 - paramInt);
/* */ }
/* */
/* */ public TextLineComponent getSubset(int paramInt1, int paramInt2, int paramInt3) {
/* 892 */ return new ExtendedTextSourceLabel(this.source.getSubSource(paramInt1, paramInt2 - paramInt1, paramInt3), this.decorator);
/* */ }
/* */
/* */
/* */ public String toString() {
/* 897 */ return this.source.toString(false);
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public int getNumJustificationInfos() {
/* 931 */ return getGV().getNumGlyphs();
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */ public void getJustificationInfos(GlyphJustificationInfo[] paramArrayOfGlyphJustificationInfo, int paramInt1, int paramInt2, int paramInt3) {
/* 941 */ StandardGlyphVector standardGlyphVector = getGV();
/* */
/* 943 */ float[] arrayOfFloat = getCharinfo();
/* */
/* 945 */ float f = standardGlyphVector.getFont().getSize2D();
/* */
/* 947 */ GlyphJustificationInfo glyphJustificationInfo1 = new GlyphJustificationInfo(0.0F, false, 3, 0.0F, 0.0F, false, 3, 0.0F, 0.0F);
/* */
/* */
/* */
/* */
/* 952 */ GlyphJustificationInfo glyphJustificationInfo2 = new GlyphJustificationInfo(f, true, 1, 0.0F, f, true, 1, 0.0F, f / 4.0F);
/* */
/* */
/* */
/* */
/* 957 */ GlyphJustificationInfo glyphJustificationInfo3 = new GlyphJustificationInfo(f, true, 2, f, f, false, 3, 0.0F, 0.0F);
/* */
/* */
/* */
/* */
/* 962 */ char[] arrayOfChar = this.source.getChars();
/* 963 */ int i = this.source.getStart();
/* */
/* */
/* */
/* 967 */ int j = standardGlyphVector.getNumGlyphs();
/* 968 */ int k = 0;
/* 969 */ int m = j;
/* 970 */ boolean bool = ((this.source.getLayoutFlags() & 0x1) == 0) ? true : false;
/* 971 */ if (paramInt2 != 0 || paramInt3 != this.source.getLength()) {
/* 972 */ if (bool) {
/* 973 */ k = paramInt2;
/* 974 */ m = paramInt3;
/* */ } else {
/* 976 */ k = j - paramInt3;
/* 977 */ m = j - paramInt2;
/* */ }
/* */ }
/* */
/* 981 */ for (byte b = 0; b < j; b++) {
/* 982 */ GlyphJustificationInfo glyphJustificationInfo = null;
/* 983 */ if (b >= k && b < m) {
/* 984 */ if (arrayOfFloat[b * 8 + 2] == 0.0F) {
/* 985 */ glyphJustificationInfo = glyphJustificationInfo1;
/* */ } else {
/* 987 */ int n = v2l(b);
/* 988 */ char c = arrayOfChar[i + n];
/* 989 */ if (Character.isWhitespace(c)) {
/* 990 */ glyphJustificationInfo = glyphJustificationInfo2;
/* */ }
/* 992 */ else if ((c >= 'ไธ' && c < '๊') || (c >= '๊ฐ' && c < 'ํฐ') || (c >= '๏ค' && c < '๏ฌ')) {
/* */
/* */
/* */
/* 996 */ glyphJustificationInfo = glyphJustificationInfo3;
/* */ } else {
/* 998 */ glyphJustificationInfo = glyphJustificationInfo1;
/* */ }
/* */ }
/* */ }
/* 1002 */ paramArrayOfGlyphJustificationInfo[paramInt1 + b] = glyphJustificationInfo;
/* */ }
/* */ }
/* */
/* */
/* */
/* */
/* */
/* */ public TextLineComponent applyJustificationDeltas(float[] paramArrayOffloat, int paramInt, boolean[] paramArrayOfboolean) {
/* 1011 */ float[] arrayOfFloat1 = (float[])getCharinfo().clone();
/* */
/* */
/* 1014 */ paramArrayOfboolean[0] = false;
/* */
/* */
/* */
/* 1018 */ StandardGlyphVector standardGlyphVector = (StandardGlyphVector)getGV().clone();
/* 1019 */ float[] arrayOfFloat2 = standardGlyphVector.getGlyphPositions(null);
/* 1020 */ int i = standardGlyphVector.getNumGlyphs();
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 1035 */ char[] arrayOfChar = this.source.getChars();
/* 1036 */ int j = this.source.getStart();
/* */
/* */
/* */
/* */
/* */
/* 1042 */ float f = 0.0F;
/* 1043 */ for (byte b = 0; b < i; b++) {
/* 1044 */ if (Character.isWhitespace(arrayOfChar[j + v2l(b)])) {
/* 1045 */ arrayOfFloat2[b * 2] = arrayOfFloat2[b * 2] + f;
/* */
/* 1047 */ float f1 = paramArrayOffloat[paramInt + b * 2] + paramArrayOffloat[paramInt + b * 2 + 1];
/* */
/* 1049 */ arrayOfFloat1[b * 8 + 0] = arrayOfFloat1[b * 8 + 0] + f;
/* 1050 */ arrayOfFloat1[b * 8 + 4] = arrayOfFloat1[b * 8 + 4] + f;
/* 1051 */ arrayOfFloat1[b * 8 + 2] = arrayOfFloat1[b * 8 + 2] + f1;
/* */
/* 1053 */ f += f1;
/* */ } else {
/* 1055 */ f += paramArrayOffloat[paramInt + b * 2];
/* */
/* 1057 */ arrayOfFloat2[b * 2] = arrayOfFloat2[b * 2] + f;
/* 1058 */ arrayOfFloat1[b * 8 + 0] = arrayOfFloat1[b * 8 + 0] + f;
/* 1059 */ arrayOfFloat1[b * 8 + 4] = arrayOfFloat1[b * 8 + 4] + f;
/* */
/* 1061 */ f += paramArrayOffloat[paramInt + b * 2 + 1];
/* */ }
/* */ }
/* 1064 */ arrayOfFloat2[i * 2] = arrayOfFloat2[i * 2] + f;
/* */
/* 1066 */ standardGlyphVector.setGlyphPositions(arrayOfFloat2);
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* 1076 */ ExtendedTextSourceLabel extendedTextSourceLabel = new ExtendedTextSourceLabel(this.source, this.decorator);
/* 1077 */ extendedTextSourceLabel.gv = standardGlyphVector;
/* 1078 */ extendedTextSourceLabel.charinfo = arrayOfFloat1;
/* */
/* 1080 */ return extendedTextSourceLabel;
/* */ }
/* */ }
/* Location: D:\tools\env\Java\jdk1.8.0_211\rt.jar!\sun\font\ExtendedTextSourceLabel.class
* Java compiler version: 8 (52.0)
* JD-Core Version: 1.1.3
*/ | [
"xknower@126.com"
] | xknower@126.com |
13d13cf4246edd7eed3cd76278391f93535dc10a | 8fa8c3226e163273992dde7a52749191cc9ddb16 | /src/main/java/annotation/TV.java | 6d4d5a1f90f5a878aa39774873571c40ba57c29d | [] | no_license | witness0109/KITRI_ACADEMY | e6548ea0dfedaf6f64a192b3abf400d3b559c574 | 8c053ecfa8caf974213b97189bd40a6791ddc5d6 | refs/heads/master | 2022-12-22T22:58:39.848661 | 2021-03-14T12:45:29 | 2021-03-14T12:45:29 | 237,117,573 | 0 | 0 | null | 2022-12-16T09:45:03 | 2020-01-30T01:31:34 | Java | UTF-8 | Java | false | false | 171 | java | package annotation;
public interface TV {
public void powerOn();
public void powerOff();
public void soundUp();
public void soundDown();
public void BavelBBova();
}
| [
"59610521+witness0109@users.noreply.github.com"
] | 59610521+witness0109@users.noreply.github.com |
cb8892e9e9f5a2cb4e92597a9b0b6e8f251b9608 | 0a1d99a57e17345250d5dbdb13426b276c9d0160 | /demo-apply/src/main/java/com/demo/demoapply/DemoApplyApplication.java | 8874eb3882b22d1ea99641ee8b620f698d50de98 | [] | no_license | civilazation/demo-parent | 0497fc5f055b3e6ea82523dd299d4a103c23b544 | a57503f5ad50ec501c0e881fb3a5d7e736bb495f | refs/heads/master | 2022-12-01T13:08:59.334552 | 2020-08-10T03:49:52 | 2020-08-10T03:49:52 | 286,370,020 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 329 | java | package com.demo.demoapply;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplyApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplyApplication.class, args);
}
}
| [
"1635107058@qq.com"
] | 1635107058@qq.com |
bef8293e3947fdd3d1c7a61644862a984eedf365 | dd3dc7ea6bb879353824ef8fff4fde3573c1ddde | /src/movie/view/AdminLoginControl.java | 0c9df4f9bd5421c4b2299f047b3200fa1e6ff173 | [] | no_license | Sagar0320/The-Movie-Database | e1d666e0fdfa189cba789ea66939a19dc573e633 | 9328feca7430012c7ae5c10be3ae0fa8b71c6842 | refs/heads/master | 2021-08-30T23:21:49.305453 | 2017-12-19T20:19:19 | 2017-12-19T20:19:19 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,670 | java | package movie.view;
import java.io.IOException;
import java.sql.SQLException;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.PasswordField;
import javafx.scene.control.TextField;
import javafx.scene.layout.AnchorPane;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import movie.Main;
import movie.model.MovieModel;
public class AdminLoginControl extends AnchorPane
{
@FXML
private Label isConnected;
@FXML
private Text unpw;
@FXML
private Button loginBT;
@FXML
private Button backBT;
@FXML
private TextField unTF;
@FXML
private TextField pwPF;
public MovieModel mm = new MovieModel();
@FXML
public void Login() throws IOException
{
try
{
if(mm.isLogin(unTF.getText(), pwPF.getText()))
{
Stage primaryStage;
primaryStage = (Stage)loginBT.getScene().getWindow();
FXMLLoader loader = new FXMLLoader(); //check file name here
loader.setLocation(Main.class.getResource("view/AdminHome.fxml"));
AnchorPane rootLayout = (AnchorPane) loader.load();
// Show the scene containing the root layout.
Scene scene = new Scene(rootLayout);
primaryStage.setScene(scene);
primaryStage.show();
}else
{
unpw.setText("username and password is incorrect");
}
} catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@FXML
public void loadAdminHomePage()
{
//System.out.println("Button clicked");
try {
Stage primaryStage;
primaryStage = (Stage)loginBT.getScene().getWindow();
FXMLLoader loader = new FXMLLoader(); //check file name here
loader.setLocation(Main.class.getResource("view/AdminHome.fxml"));
AnchorPane rootLayout = (AnchorPane) loader.load();
// Show the scene containing the root layout.
Scene scene = new Scene(rootLayout);
primaryStage.setScene(scene);
primaryStage.show();
}
catch(IOException e)
{
e.printStackTrace();
}
}
@FXML
public void loadPrevPage()
{
//System.out.println("Button clicked");
try {
Stage primaryStage;
primaryStage = (Stage)backBT.getScene().getWindow();
FXMLLoader loader = new FXMLLoader(); //check file name here
loader.setLocation(Main.class.getResource("view/FirstScreen.fxml"));
AnchorPane rootLayout = (AnchorPane) loader.load();
// Show the scene containing the root layout.
Scene scene = new Scene(rootLayout);
primaryStage.setScene(scene);
primaryStage.show();
}
catch(IOException e)
{
e.printStackTrace();
}
}
} | [
"31051996+sagarhansalia@users.noreply.github.com"
] | 31051996+sagarhansalia@users.noreply.github.com |
6e7bb49a5ff333ed4898d708718afb669e16dd52 | 68a9ad98440e6716f3eefcdd668d56cee240f677 | /app/src/main/java/net/mijack/paperapp/holder/GroupHolder.java | a4d0c75f0d6961eeb188f8c347659a0e8cc5303b | [
"Apache-2.0"
] | permissive | MiJack/PaperApp | a7e632fcf847e0c718306fc078b6977b32e39a4e | e28db93f891a6a76aae63896ffbaa2f0edaae108 | refs/heads/master | 2021-01-17T16:00:41.807623 | 2016-05-18T10:04:52 | 2016-05-18T10:04:52 | 58,610,065 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,285 | java | package net.mijack.paperapp.holder;
import android.content.res.Resources;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.TextView;
import net.mijack.paperapp.R;
import net.mijack.paperapp.bean.PermissionGroupResult;
/**
* @author MiJack
* @since 2016/5/18
*/
public class GroupHolder extends RecyclerView.ViewHolder {
private TextView groupLabel;
private TextView groupName;
private TextView groupDesc;
private TextView groupStatisticName;
public GroupHolder(View itemView) {
super(itemView);
groupLabel = (TextView) itemView.findViewById(R.id.groupLabel);
groupName = (TextView) itemView.findViewById(R.id.groupName);
groupDesc = (TextView) itemView.findViewById(R.id.groupDesc);
groupStatisticName = (TextView) itemView.findViewById(R.id.groupStatisticName);
}
public void bindData(PermissionGroupResult result) {
Resources resources = groupStatisticName.getResources();
groupLabel.setText(result.getLabel());
groupName.setText(result.getName());
groupDesc.setText(result.getDescription());
groupStatisticName.setText(resources.getString(R.string.group_statistic,
result.getPermissionCount()));
}
}
| [
"893380824@qq.com"
] | 893380824@qq.com |
4a3f05371a6869c1d5abcdfcb22d0949d4cc4c9a | e04c596465a5099bfb968cff1510f495e8e83fde | /AM-Resources/src/main/java/am/main/data/enums/Folders.java | c1c39ae4425a2fad5d45d6f12c6d08bd178bba75 | [] | no_license | AhmedMater/AM | 47adb350706656081683ec6cca05f63e472531b9 | 1e0d11f16d71abd37e83348073e32cf1885a6ccc | refs/heads/master | 2021-01-13T09:47:00.052056 | 2018-02-13T03:47:05 | 2018-02-13T03:47:05 | 71,176,787 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 761 | java | package am.main.data.enums;
/**
* Created by ahmed.motair on 1/14/2018.
*/
public enum Folders {
EMAIL_TEMPLATES("EM", "Templates/Email"),
SMS_TEMPLATES("SMS", "Templates/SMS"),
WEB_NOTIFICATION_TEMPLATES("Web-Notification", "Templates/Web-Notification");
private final String name;
private final String path;
Folders(String name, String path){
this.name = name;
this.path = path;
}
public String folderName() {
return name;
}
public String folderPath() {
return path;
}
@Override
public String toString() {
return "Folders{" +
"name = " + name +
", path = " + path +
"}\n";
}
}
| [
"ahmedmotair@gmail.com"
] | ahmedmotair@gmail.com |
869a663899b4c7292f3760b6999ac254ed771fd8 | aa0965b5490af27c7a5e19a6fecb30cd6acf30f7 | /Auraapp/src/main/java/com/dhanrajapp/action/UpdatePending.java | 38495c56d8e352f4f5c81dd4e8f68451ed525ec3 | [] | no_license | narendrasuthar1/Auroapp | 6c28bc04b6aea042712c5421b268760715a6c40a | 7f620bac26a5d72b6255808fff8cc7f87db01e47 | refs/heads/master | 2023-02-23T02:31:27.451524 | 2021-01-28T09:19:23 | 2021-01-28T09:19:23 | 331,878,113 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 646 | java | package com.dhanrajapp.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
public class UpdatePending extends Action {
@Override
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
HttpServletResponse response) throws Exception {
System.out.println(request.getParameter("delete"));
return super.execute(mapping, form, request, response);
}
}
| [
"Rounak Suthar@Rounak-PC01"
] | Rounak Suthar@Rounak-PC01 |
48331d08f1511c6070f1413612c5a021fbd8a104 | df22e3ba8a5603cb37d62884062d84e3f9736963 | /source/Chemin.java | 9459d937e2353b7d024b16dd31cc0109d349b512 | [] | no_license | Hazreath/RechercheChemin | b88a43553190caf351e0835eb7f76947ebae401a | aa8fa733657a0e3c0900c05ead5db9332f1ec300 | refs/heads/master | 2020-04-29T18:37:40.075116 | 2019-04-06T11:23:21 | 2019-04-06T11:23:21 | 176,329,529 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 286 | java | import java.util.List;
public class Chemin {
private List<int[]> contenu;
public List<int[]> getContenu() {
return contenu;
}
public void setContenu(List<int[]> contenu) {
this.contenu = contenu;
}
public boolean tester(Resultat r) {
return true;
}
}
| [
"noreply@github.com"
] | noreply@github.com |
02621c2774cfa4b2dbc5f3aebbf10843b91414fc | 95b35f110818c9806cced65f086da352a7fc1a99 | /service/src/main/java/hasan/kara/service/security/JwtProvider.java | 36375cb830a39f83a9d8a6069426b47b81f07e85 | [] | no_license | hasankara/spring-boot-multi-module-project | 49e22e16892b56718a3841166611bd7a17ecdd9b | b540c27b4521d5008fd43b4f8e841357161fbd2f | refs/heads/master | 2022-11-21T00:08:03.281213 | 2020-07-21T10:44:20 | 2020-07-21T10:44:20 | 279,529,800 | 2 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,284 | java | package hasan.kara.service.security;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Component;
import hasan.kara.domain.entity.User;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.SignatureException;
import io.jsonwebtoken.UnsupportedJwtException;
@Component
public class JwtProvider {
private static final Logger logger = LoggerFactory.getLogger(JwtProvider.class);
@Value("${jwt.secret}")
private String jwtSecret;
@Value("${jwt.expiration}")
private int jwtExpiration;
public String generateJwtToken(Authentication authentication) {
User user = (User) authentication.getPrincipal();
return Jwts.builder()
.setSubject((user.getUsername()))
.setIssuedAt(new Date())
.setExpiration(new Date((new Date()).getTime() + jwtExpiration*1000))
.signWith(SignatureAlgorithm.HS512, jwtSecret)
.compact();
}
public boolean validateJwtToken(String authToken) {
try {
Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
return true;
} catch (SignatureException e) {
logger.error("Invalid JWT signature -> Message: {} ", e);
} catch (MalformedJwtException e) {
logger.error("Invalid JWT token -> Message: {}", e);
} catch (ExpiredJwtException e) {
logger.error("Expired JWT token -> Message: {}", e);
} catch (UnsupportedJwtException e) {
logger.error("Unsupported JWT token -> Message: {}", e);
} catch (IllegalArgumentException e) {
logger.error("JWT claims string is empty -> Message: {}", e);
}
return false;
}
public String getUserNameFromJwtToken(String token) {
return Jwts.parser()
.setSigningKey(jwtSecret)
.parseClaimsJws(token)
.getBody().getSubject();
}
} | [
"h.kara27@gmail.com"
] | h.kara27@gmail.com |
e01935148de4dc9870d94386f8e8a8ab961b976f | f9827cc79546f6ad1bcb29772a0d78ce89fda559 | /src/main/java/student/manchester/dao/user/BindDao.java | 452f201d2e3930cf3a2ece85295b2c281451a323 | [
"MIT"
] | permissive | Anastasov/rebind | d064e14b161e554e9fe3d1095fd010d6b3dd29d7 | cc87419f18eb224ccaae495838286195388a3f77 | refs/heads/master | 2020-04-23T20:26:06.647216 | 2019-02-19T09:50:45 | 2019-02-19T09:50:45 | 171,440,168 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 239 | java | package student.manchester.dao.user;
import student.manchester.dao.GenericDao;
import student.manchester.model.bind.Bind;
/**
* @author Anastas Anastasov
* on 11/17/2018.
*/
public interface BindDao extends GenericDao<Bind, Long> {
}
| [
"anastas.anastasov@student.manchester.ac.uk"
] | anastas.anastasov@student.manchester.ac.uk |
ab13eaa206cbfcccf9f305852810871f5a7dd1b2 | 20d2c61bb5aa062e1056f6249e80986b07c49ca9 | /cas-server/src/main/java/com/ybin/casserver/test/Test.java | bc45612141a1335776a85fbcac28cbd009fcfe22 | [
"Apache-2.0"
] | permissive | ybinpvt/cloudtemplate | 5adaecdd79add3edb7a9e6bf8f2d5f3999bf9bd1 | 5c2e31c0de67e227e2c8af55fad6d21902c35438 | refs/heads/master | 2023-02-15T16:53:03.857717 | 2021-01-15T03:36:36 | 2021-01-15T03:36:36 | 306,237,715 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 338 | java | package com.ybin.casserver.test;
import lombok.val;
/**
* @author ybin
* @version 1.0
* @date 2021/1/11 18:25
* @description:
*/
public class Test {
public static void main(String[] args) {
String ๆฏ = "ๆฏ";
val ๅฆ = "ไธๆฏ";
System.out.println("ๅฐๅบๆฏ" + ๆฏ + "่ฟๆฏ" + ๅฆ + "๏ผ");
}
}
| [
"bin.yang@ribo.com.cn"
] | bin.yang@ribo.com.cn |
83f7ad3c41bfd06d825959556067130209c7b33d | 1cadc4f690060a429807be9a9d5d02b06ae46356 | /QuickReference/src/reference/jf18/example/MainFruit.java | 1bb32d1f06e8c71ca962688dde24d66756600848 | [] | no_license | jesushalfonzo/netbeans | 06e10fe6671ae6030bfeb17ed527ed04a7a866dc | da52ce761359c3fc02e6ffa6f8dbae0bdf1a4c30 | refs/heads/master | 2021-01-13T09:10:10.637031 | 2016-09-30T17:56:53 | 2016-09-30T17:56:53 | 69,689,246 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 970 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package reference.jf18.example;
/**
*
* @author yecheverria
*/
public class MainFruit {
public static void main(String [] p ){
BoxFruit<Fruit> box = new BoxFruit<>();
Mango mango1 = new Mango();
Mango mango = new Mango();
Pera pera = new Pera();
Fresa fresa = new Fresa();
box.addFruit(mango1);
box.addFruit(mango);
box.addFruit(fresa);
box.addFruit(fresa);
box.addFruit(fresa);
box.addFruit(fresa);
box.addFruit(fresa);
box.addFruit(pera);
System.out.println("Mango: " + box.countFruit(mango));
System.out.println("fresa: " + box.countFruit(fresa));
System.out.println("pera: " + box.countFruit(pera));
}
}
| [
"you@example.com"
] | you@example.com |
14178f1563e205dcc8d90e600a3b9861506c9725 | 32c2d3a7188690a7da315e783437653492ab56b3 | /AndroidStudioProjects/MyRestaurants/app/src/main/java/com/epicodus/myrestaurants/adapters/FirebaseRestaurantViewHolder.java | 49628b7d4c04d2f0c79ebb89581a1935abf66cc6 | [] | no_license | trivassi/MyRestaurants-mac | 0a3a900d93a179413d19f7fecda45bb4588bd502 | ead798a4b1f29540605e90bb6f3df8f83423dee8 | refs/heads/master | 2020-07-06T11:17:57.459764 | 2016-12-11T11:18:25 | 2016-12-11T11:18:25 | 74,044,517 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,734 | java | package com.epicodus.myrestaurants.adapters;
import android.content.Context;
import android.content.Intent;
import android.media.Image;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import com.epicodus.myrestaurants.Constants;
import com.epicodus.myrestaurants.R;
import com.epicodus.myrestaurants.models.Restaurant;
import com.epicodus.myrestaurants.ui.RestaurantDetailActivity;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;
import com.squareup.picasso.Picasso;
import org.parceler.Parcels;
import java.util.ArrayList;
/**
* Created by T on 12/6/16.
*/
public class FirebaseRestaurantViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
private static final int MAX_WIDTH = 200;
private static final int MAX_HEIGHT = 200;
//add member variables to hold the view and context which we set in our constructor
View mView;
Context mContext;
//implement the View.OnClickListener interface and set the click listener on our itemView
public FirebaseRestaurantViewHolder(View itemView) {
super(itemView);
mView = itemView;
mContext = itemView.getContext();
itemView.setOnClickListener(this);
}
public void bindRestaurant (Restaurant restaurant) {
//first bind the views
ImageView restaurantImageView = (ImageView) mView.findViewById(R.id.restaurantImageView);
TextView nameTextView = (TextView) mView.findViewById(R.id.restaurantNameTextView);
TextView categoryTextView = (TextView) mView.findViewById(R.id.categoryTextView);
TextView ratingTextView = (TextView) mView.findViewById(R.id.ratingTextView);
Picasso.with(mContext)
.load(restaurant.getImageUrl())
.resize(MAX_WIDTH, MAX_HEIGHT)
.centerCrop()
.into(restaurantImageView);
//then set the image and text views
nameTextView.setText(restaurant.getName());
categoryTextView.setText(restaurant.getCategories().get(0));
ratingTextView.setText("Rating" + restaurant.getRating() + "/5");
}
@Override
public void onClick(View view) {
//create a singleValueEventListener to grab out the current list of restaurants from Firebase
final ArrayList<Restaurant> restaurants = new ArrayList<>();
DatabaseReference ref = FirebaseDatabase.getInstance().getReference(Constants.FIREBASE_CHILD_RESTAURANTS);
ref.addValueEventListener(new ValueEventListener() { //1. create a singleValueEventListener to grab out the current list of restaurants from Firebase
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
for (DataSnapshot snapshot : dataSnapshot.getChildren()) {
restaurants.add(snapshot.getValue(Restaurant.class));
}
int itemPosition = getLayoutPosition();
//2. which we pass along to the RestaurantDetailActivity in the form of an intent extra.
Intent intent = new Intent(mContext, RestaurantDetailActivity.class);
intent.putExtra("position", itemPosition + "");
intent.putExtra("restaurant", Parcels.wrap(restaurants));
mContext.startActivity(intent);
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
}
| [
"rivassi.thomas@gmail.com"
] | rivassi.thomas@gmail.com |
ff3656d37a83dc4621036cc063ed89fb66be2065 | 98ed9bd9433aca2e70165e63eaa85f251987574a | /app/src/test/java/com/example/compare_gas/ExampleUnitTest.java | 86c2649b41dd64e13b63765975700a3650039875 | [] | no_license | Caboaros/compare_gas | 729a951b6c954c46bbda1987fb8793571b2b9e09 | c1419f14d74644ab27e5f6a625fbc4379fb437a8 | refs/heads/master | 2023-05-02T17:25:56.400795 | 2021-05-30T03:31:35 | 2021-05-30T03:31:35 | 372,107,938 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 384 | java | package com.example.compare_gas;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() {
assertEquals(4, 2 + 2);
}
} | [
"celsocomcarinho@gmail.com"
] | celsocomcarinho@gmail.com |
92f4b393d188fe5c9ed6f293826f42666ff34015 | 32b72e1dc8b6ee1be2e80bb70a03a021c83db550 | /ast_results/rtyley_agit/agit/src/main/java/com/madgag/agit/git/model/Relation.java | 0d3ed61816c4b0aec69d996a68d6bed349a97429 | [] | no_license | cmFodWx5YWRhdjEyMTA5/smell-and-machine-learning | d90c41a17e88fcd99d543124eeb6e93f9133cb4a | 0564143d92f8024ff5fa6b659c2baebf827582b1 | refs/heads/master | 2020-07-13T13:53:40.297493 | 2019-01-11T11:51:18 | 2019-01-11T11:51:18 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,117 | java | // isComment
package com.madgag.agit.git.model;
import static com.google.common.collect.Lists.newArrayListWithExpectedSize;
import static java.util.Arrays.asList;
import java.util.List;
import org.eclipse.jgit.revplot.PlotCommit;
import org.eclipse.jgit.revplot.PlotLane;
public enum Relation {
PARENT {
@SuppressWarnings({ "isStringConstant", "isStringConstant" })
public List<PlotCommit<PlotLane>> isMethod(PlotCommit<PlotLane> isParameter) {
return (List) isMethod(isNameExpr.isMethod());
}
}
, CHILD {
@SuppressWarnings({ "isStringConstant" })
public List<PlotCommit<PlotLane>> isMethod(PlotCommit<PlotLane> isParameter) {
List<PlotCommit<PlotLane>> isVariable = isMethod(isNameExpr.isMethod());
for (int isVariable = isIntegerConstant; isNameExpr < isNameExpr.isMethod(); ++isNameExpr) {
isNameExpr.isMethod(isNameExpr.isMethod(isNameExpr));
}
return isNameExpr;
}
}
;
public abstract List<PlotCommit<PlotLane>> isMethod(PlotCommit<PlotLane> isParameter);
}
| [
"matheus@melsolucoes.net"
] | matheus@melsolucoes.net |
6a2717b6ad1e00210f6abd566a28b091041d7127 | 18bed199cd8a0d39c273d2d4cb5c426ba1d8d67c | /rultor-base/src/main/java/com/rultor/base/Crontab.java | aca2cc59fe6e1087e4cdc7ed6b000a051e705887 | [
"BSD-2-Clause"
] | permissive | ayoubb/rultor | 5b3da836c494aa9975dcfc7da910266347d6a465 | d57aadcb2cfc832da91fa5a103e1d1200765bff6 | refs/heads/master | 2021-01-25T00:28:57.092304 | 2013-09-17T17:17:43 | 2013-09-17T17:17:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 18,430 | java | /**
* Copyright (c) 2009-2013, rultor.com
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met: 1) Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer. 2) Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution. 3) Neither the name of the rultor.com nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.rultor.base;
import com.google.common.collect.ImmutableMap;
import com.jcabi.aspects.Immutable;
import com.jcabi.aspects.Loggable;
import com.jcabi.aspects.Tv;
import com.jcabi.immutable.Array;
import com.jcabi.log.Logger;
import com.rultor.snapshot.Step;
import com.rultor.spi.Coordinates;
import com.rultor.spi.Instance;
import com.rultor.tools.Time;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;
import javax.validation.constraints.NotNull;
import lombok.EqualsAndHashCode;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
/**
* Sends pulses through, only on certain time moments.
*
* <p>Use it as an instance wrapper:
*
* <pre> com.rultor.base.Crontab(
* ${0:?}, "A/5 * * * *",
* my-custom-instance
* )</pre>
*
* @author Yegor Bugayenko (yegor@tpc2.com)
* @version $Id$
* @since 1.0
* @checkstyle ClassDataAbstractionCoupling (500 lines)
* @see <a href="https://en.wikipedia.org/wiki/Cron">Cron in Wikipedia</a>
* @see <a href="http://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html">Crontab specification</a>
*/
@Immutable
@EqualsAndHashCode(of = { "work", "origin", "gates" })
@Loggable(Loggable.DEBUG)
@SuppressWarnings({ "PMD.TooManyMethods", "PMD.CyclomaticComplexity" })
public final class Crontab implements Instance {
/**
* Pre-defined definitions.
* @see <a href="https://en.wikipedia.org/wiki/Cron#Predefined_scheduling_definitions">explanation</a>
*/
private static final ImmutableMap<String, String> DEFS =
new ImmutableMap.Builder<String, String>()
// @checkstyle MultipleStringLiterals (1 line)
.put("@yearly", "0 0 1 1 *")
.put("@annually", "0 0 1 1 *")
.put("@monthly", "0 0 1 * *")
.put("@weekly", "0 0 * * 0")
.put("@daily", "0 0 * * *")
.put("@hourly", "0 * * * *")
.build();
/**
* Coordinates we're in.
*/
private final transient Coordinates work;
/**
* Origin.
*/
private final transient Instance origin;
/**
* All gates.
*/
private final transient Array<Crontab.Gate<Calendar>> gates;
/**
* Public ctor.
* @param wrk Coordinates we're in
* @param text Mask to use
* @param instance Original instance
*/
public Crontab(
@NotNull(message = "work can't be NULL") final Coordinates wrk,
@NotNull(message = "crontab text can't be NULL") final String text,
@NotNull(message = "instance can't be NULL") final Instance instance) {
this.work = wrk;
this.origin = instance;
this.gates = new Array<Crontab.Gate<Calendar>>(Crontab.split(text));
}
/**
* {@inheritDoc}
*/
@Override
@Loggable(value = Loggable.DEBUG, limit = Integer.MAX_VALUE)
public void pulse() throws Exception {
if (this.allowed()) {
this.origin.pulse();
}
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return Logger.format("%s in %[ms]s", this.origin, this.lag(new Time()));
}
/**
* Show all encapsulated rules.
* @return The text
*/
public String rules() {
return StringUtils.join(this.gates, " ");
}
/**
* Lag in milliseconds (how much time left till the next execution).
*
* <p>The method is public solely for the sake of unit testing.
* Otherwise it's almost impossible to test the class.
*
* @param date The date to start counting from
* @return Milliseconds
*/
public long lag(final Time date) {
final Calendar today = Crontab.calendar(date);
long lag = 0;
for (Crontab.Gate<Calendar> gate : this.gates) {
lag += gate.lag(today);
}
return lag;
}
/**
* Execution allowed?
* @return TRUE if allowed
*/
@Step("Crontab `${this.rules}` #if(!$result)NOT#end allowed execution")
private boolean allowed() {
final Calendar today = Crontab.calendar(this.work.scheduled());
Crontab.Gate<Calendar> denier = null;
for (Crontab.Gate<Calendar> gate : this.gates) {
if (!gate.pass(today)) {
denier = gate;
break;
}
}
if (denier == null) {
Logger.info(
this,
"Crontab `%s` allows execution at `%s`",
this.rules(),
Crontab.moment(this.work.scheduled())
);
} else {
Logger.info(
this,
// @checkstyle LineLength (1 line)
"Not the right moment `%s` for `%s`, see you again in %[ms]s (denied by `%s`)",
Crontab.moment(this.work.scheduled()),
this.rules(),
this.lag(this.work.scheduled()),
denier
);
}
return denier == null;
}
/**
* Gate condition.
*/
@Immutable
private interface Gate<T> {
/**
* Pass or not.
* @param calendar Calendar to check
* @return TRUE if it's a good time to go through
*/
boolean pass(T calendar);
/**
* How many milliseconds to wait before the next opportunity.
* @param calendar Calendar to check
* @return Lag in milliseconds
*/
long lag(T calendar);
}
/**
* Abstract big gate.
*/
@Immutable
@EqualsAndHashCode(of = "alternatives")
@Loggable(Loggable.DEBUG)
private abstract static class AbstractBigGate
implements Crontab.Gate<Calendar> {
/**
* All alternatives.
*/
private final transient Array<Crontab.Gate<Integer>> alternatives;
/**
* Public ctor.
* @param text Text spec
*/
@SuppressWarnings("unchecked")
protected AbstractBigGate(final String text) {
final String[] parts = text.split(",");
final Collection<Crontab.Gate<Integer>> alts =
new ArrayList<Crontab.Gate<Integer>>(parts.length);
for (int idx = 0; idx < parts.length; ++idx) {
alts.add(Crontab.parse(parts[idx]));
}
this.alternatives = new Array<Crontab.Gate<Integer>>(alts);
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return StringUtils.join(this.alternatives, "|");
}
/**
* Matches the number?
* @param input Input number
* @return TRUE if matches
*/
protected boolean matches(final int input) {
boolean matches = false;
for (Crontab.Gate<Integer> alternative : this.alternatives) {
if (alternative.pass(input)) {
matches = true;
break;
}
}
return matches;
}
/**
* Calculate the lag.
* @param input Input number
* @return Lag in milliseconds
*/
protected long lag(final int input) {
long lag = Long.MAX_VALUE;
for (Crontab.Gate<Integer> alternative : this.alternatives) {
lag = Math.min(lag, alternative.lag(input));
}
return lag;
}
}
/**
* Exact gate.
*/
@Immutable
@EqualsAndHashCode(of = "exact")
@Loggable(Loggable.DEBUG)
private static final class ExactGate implements Crontab.Gate<Integer> {
/**
* Exact value to match.
*/
private final transient int exact;
/**
* Protected ctor.
* @param val The value to encapsulate
*/
protected ExactGate(final int val) {
this.exact = val;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return Integer.toString(this.exact);
}
/**
* {@inheritDoc}
*/
@Override
public boolean pass(final Integer num) {
return num == this.exact;
}
/**
* {@inheritDoc}
*/
@Override
public long lag(final Integer num) {
return Math.abs(num - this.exact);
}
}
/**
* Interval gate.
*/
@Immutable
@EqualsAndHashCode(of = { "left", "right" })
@Loggable(Loggable.DEBUG)
private static final class IntervalGate implements Crontab.Gate<Integer> {
/**
* Left, inclusive.
*/
private final transient int left;
/**
* Right, inclusive.
*/
private final transient int right;
/**
* Protected ctor.
* @param lft Left, inclusive
* @param rgt Right, inclusive
*/
protected IntervalGate(final int lft, final int rgt) {
Validate.isTrue(
lft < rgt, "left value %d should be less than right %d",
lft, rgt
);
this.left = lft;
this.right = rgt;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return String.format("%d-%d", this.left, this.right);
}
/**
* {@inheritDoc}
*/
@Override
public boolean pass(final Integer num) {
return num >= this.left && num <= this.right;
}
/**
* {@inheritDoc}
*/
@Override
public long lag(final Integer num) {
long lag = 0;
if (!this.pass(num)) {
lag = Math.abs(num - this.left);
}
return lag;
}
}
/**
* Modulo gate.
*/
@Immutable
@EqualsAndHashCode(of = "divisor")
@Loggable(Loggable.DEBUG)
private static final class ModuloGate implements Crontab.Gate<Integer> {
/**
* Divisor.
*/
private final transient int divisor;
/**
* Protected ctor.
* @param div The divisor
*/
protected ModuloGate(final int div) {
Validate.isTrue(
div > 0, "divisor %d has to be positive and non-zero",
div
);
this.divisor = div;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return String.format("*/%d", this.divisor);
}
/**
* {@inheritDoc}
*/
@Override
public boolean pass(final Integer num) {
return num % this.divisor == 0;
}
/**
* {@inheritDoc}
*/
@Override
public long lag(final Integer num) {
long lag = 0;
if (!this.pass(num)) {
lag = ((num + this.divisor - 1)
/ this.divisor) * this.divisor - num;
}
return lag;
}
}
/**
* Parse text into alternative.
* @param part The text to parse
* @return Small gate condition
*/
private static Crontab.Gate<Integer> parse(final String part) {
final Crontab.Gate<Integer> alternative;
if (part.matches("\\d+")) {
alternative = new Crontab.ExactGate(Integer.parseInt(part));
} else if (part.matches("\\d+-\\d+")) {
final String[] numbers = part.split("-");
alternative = new Crontab.IntervalGate(
Integer.parseInt(numbers[0]), Integer.parseInt(numbers[1])
);
} else if (part.matches("\\*/\\d+")) {
alternative = new Crontab.ModuloGate(
Integer.valueOf(part.substring(part.indexOf('/') + 1))
);
// @checkstyle MultipleStringLiterals (1 line)
} else if ("*".equals(part)) {
alternative = new Crontab.Gate<Integer>() {
@Override
public String toString() {
return "*";
}
@Override
public boolean pass(final Integer num) {
return true;
}
@Override
public long lag(final Integer num) {
return 0L;
}
};
} else {
throw new IllegalArgumentException(
String.format("invalid crontab sector `%s`", part)
);
}
return alternative;
}
/**
* Split into parts.
* @param text Text to split
* @return Five parts, numbers
*/
@SuppressWarnings("unchecked")
private static Crontab.Gate<Calendar>[] split(final String text) {
String src = text;
if (Crontab.DEFS.containsKey(src)) {
src = Crontab.DEFS.get(src);
}
final String[] parts = src.split("\\s+");
if (parts.length != Tv.FIVE) {
throw new IllegalArgumentException(
String.format("invalid crontab definition `%s`", text)
);
}
return (Crontab.Gate<Calendar>[]) new Crontab.Gate<?>[] {
new Crontab.AbstractBigGate(parts[0]) {
@Override
public boolean pass(final Calendar calendar) {
return this.matches(calendar.get(Calendar.MINUTE));
}
@Override
public long lag(final Calendar calendar) {
return this.lag(
calendar.get(Calendar.MINUTE)
) * TimeUnit.MINUTES.toMillis(1);
}
},
new Crontab.AbstractBigGate(parts[1]) {
@Override
public boolean pass(final Calendar calendar) {
return this.matches(calendar.get(Calendar.HOUR_OF_DAY));
}
@Override
public long lag(final Calendar calendar) {
return this.lag(
calendar.get(Calendar.HOUR_OF_DAY)
) * TimeUnit.HOURS.toMillis(1);
}
},
new Crontab.AbstractBigGate(parts[2]) {
@Override
public boolean pass(final Calendar calendar) {
return this.matches(
calendar.get(Calendar.DAY_OF_MONTH)
);
}
@Override
public long lag(final Calendar calendar) {
return this.lag(
calendar.get(Calendar.DAY_OF_MONTH)
) * TimeUnit.DAYS.toMillis(1);
}
},
new Crontab.AbstractBigGate(parts[Tv.THREE]) {
@Override
public boolean pass(final Calendar calendar) {
return this.matches(calendar.get(Calendar.MONTH) + 1);
}
@Override
public long lag(final Calendar calendar) {
return this.lag(
calendar.get(Calendar.MONTH) + 1
) * Tv.THIRTY * TimeUnit.DAYS.toMillis(1);
}
},
new Crontab.AbstractBigGate(parts[Tv.FOUR]) {
@Override
public boolean pass(final Calendar calendar) {
return this.matches(calendar.get(Calendar.DAY_OF_WEEK));
}
@Override
public long lag(final Calendar calendar) {
return this.lag(
calendar.get(Calendar.DAY_OF_WEEK) - 1
) * TimeUnit.DAYS.toMillis(1);
}
},
};
}
/**
* Convert date to calendar.
* @param date Current date
* @return Calendar or today
*/
private static Calendar calendar(final Time date) {
final Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
cal.setTime(date.date());
cal.set(Calendar.MILLISECOND, 0);
cal.set(Calendar.SECOND, 0);
return cal;
}
/**
* Convert time into text.
* @param date The date
* @return Text in crontab format
*/
private static String moment(final Time date) {
final Calendar cal = Crontab.calendar(date);
return String.format(
"%d %d %d %d %d",
cal.get(Calendar.MINUTE),
cal.get(Calendar.HOUR_OF_DAY),
cal.get(Calendar.DAY_OF_MONTH),
cal.get(Calendar.MONTH) + 1,
cal.get(Calendar.DAY_OF_WEEK) - 1
);
}
}
| [
"yegor@tpc2.com"
] | yegor@tpc2.com |
2840e3085aaeb409ecdcb781a0f4c3ed4fe9d8d1 | bd429075eee09d38f7cab005b4dd11a2f2e694a9 | /src/HardwareItemComponents.java | fcc2558c27fa79c34b22374141e7cb4533e3e8fd | [] | no_license | marija59/ImmersiveEnvironmentsEngine | 73ef8dffc738cd58209a19d09dc47bec92f3baa1 | 5dffd1e4ada7d3a58f2eb8e1f3408c4252840d79 | refs/heads/master | 2020-05-16T02:55:33.936520 | 2013-11-12T17:42:04 | 2013-11-12T17:42:04 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 18,830 | java | import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JComboBox;
import javax.swing.JTextField;
import javax.swing.JButton;
import java.awt.EventQueue;
import java.awt.Font;
import javax.swing.JTextArea;
import java.awt.Color;
import javax.swing.JSeparator;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
@SuppressWarnings("serial")
public class HardwareItemComponents extends JFrame{
private JFrame frame;
private JTextField txtCompName;
private JTextField txtStateName;
private JTextField txtTransName;
JComboBox<comboItem> cbComponent = new JComboBox<comboItem>();
JComboBox<comboItem> cbStateFrom = new JComboBox<comboItem>();
JComboBox<comboItem> cbStateTo = new JComboBox<comboItem>();
JComboBox<comboItem> cbEvents = new JComboBox<comboItem>();
JComboBox<comboItem> cbHardwareItem = new JComboBox<comboItem>();
JComboBox<comboItem> cbHardwareItemComponent = new JComboBox<comboItem>();
JComboBox<comboItem> cbTransComponents = new JComboBox<comboItem>();
JComboBox<comboItem> cbModalityType = new JComboBox<comboItem>();
private DynamicTree treePanelHardwareItems;
private void populateTreeHardwareItems(DynamicTree treePanel) {
DefaultMutableTreeNode p1, p2;
try {
if (cbHardwareItem.getSelectedItem() != null){
treePanel.clear();
ConnectDatabase cdb = new ConnectDatabase();
ConnectDatabase cdb2 = new ConnectDatabase();
ConnectDatabase cdb3 = new ConnectDatabase();
String Query = "select mt.idmodality_types, mt.ModalityTypeName from hardware_items hi "
+ " join hardware_items_modalities him on hi.idhardware_items = him.HardwareItemID "
+ " join modality_types mt on mt.idmodality_types = him.ModalityTypeID "
+ " where hi.idhardware_items = " + Integer.toString(((comboItem)cbHardwareItem.getSelectedItem()).value);
System.out.println(Query);
ResultSet result = cdb.st.executeQuery(Query);
while(result.next()) {
p1 = treePanel.addObject(null, result.getString("ModalityTypeName"));
String QuerySeq = "select c.Name, c.idcomponents from hardware_items hi join hardware_items_components hic on hi.idhardware_items = hic.HardwareItemID "
+ " join components c on hic.ComponentID = c.idComponents where hi.idhardware_items = "+ Integer.toString(((comboItem)cbHardwareItem.getSelectedItem()).value) + " and c.ModalityTypeID = "+ result.getString("idmodality_types");
ResultSet resultSeq = cdb2.st.executeQuery(QuerySeq);
while(resultSeq.next()) {
p2 = treePanel.addObject(p1, resultSeq.getString("c.Name"));
String QuerySt = "select Name from comp_states where ComponentID = " + resultSeq.getString("c.idcomponents");
ResultSet resultSt = cdb3.st.executeQuery(QuerySt);
while(resultSt.next()) {
treePanel.addObject(p2, resultSt.getString("Name"));
}
}
}
treePanel.expand();
cdb.st.close();
cdb2.st.close();
cdb3.st.close();
}
}
catch(SQLException ex){System.out.print(ex);}
}
private void getDataStatesForComponents(){
try{
cbStateFrom.removeAllItems();
cbStateTo.removeAllItems();
if (cbTransComponents.getSelectedItem() != null){
ConnectDatabase cdb = new ConnectDatabase();
String Query = "SELECT idcomp_states, Name FROM comp_states WHERE ComponentID = " +Integer.toString(((comboItem)cbTransComponents.getSelectedItem()).value);
System.out.println(Query);
ResultSet result = cdb.st.executeQuery(Query);
cbStateFrom.addItem(new comboItem("", -1));
cbStateTo.addItem(new comboItem("", -1));
while(result.next()) {
cbStateFrom.addItem(new comboItem(result.getString("Name"), result.getInt("idcomp_states")));
cbStateTo.addItem(new comboItem(result.getString("Name"), result.getInt("idcomp_states")));
}
cdb.st.close();
}
}
catch( Exception e ) {
e.printStackTrace();
}
}
private void getDataComponentsForHardwareItem(){
try{
cbHardwareItemComponent.removeAllItems();
cbHardwareItemComponent.addItem(new comboItem("", -1));
if (cbHardwareItem.getSelectedItem() != null){
ConnectDatabase cdb = new ConnectDatabase();
ConnectDatabase cdb2 = new ConnectDatabase();
ResultSet resultModalities = cdb.st.executeQuery("select ModalityTypeID from hardware_items hi join hardware_items_modalities him on hi.idhardware_items = him.HardwareItemID where hi.idhardware_items = " + Integer.toString(((comboItem)cbHardwareItem.getSelectedItem()).value));
while(resultModalities.next()) {
String Query = "select idComponents, Name from components where ModalityTypeID = " + resultModalities.getString("ModalityTypeID");
System.out.println(Query);
ResultSet result = cdb2.st.executeQuery(Query);
while(result.next()) {
cbHardwareItemComponent.addItem(new comboItem(result.getString("Name"), result.getInt("idComponents")));
}
}
cdb.st.close();
cdb2.st.close();
}
}
catch( Exception e ) {
e.printStackTrace();
}
}
private void getData(){
try {
cbTransComponents.removeAllItems();
cbComponent.removeAllItems();
cbHardwareItem.removeAllItems();
cbHardwareItemComponent.removeAllItems();
cbEvents.removeAllItems();
cbModalityType.removeAllItems();
ConnectDatabase cdb = new ConnectDatabase();
ResultSet result = cdb.st.executeQuery("SELECT idcomponents, Name FROM components");
cbComponent.addItem(new comboItem("", -1));
cbTransComponents.addItem(new comboItem("", -1));
while(result.next()) {
cbComponent.addItem(new comboItem(result.getString("Name"), result.getInt("idcomponents")));
cbTransComponents.addItem(new comboItem(result.getString("Name"), result.getInt("idcomponents")));
}
result = cdb.st.executeQuery("SELECT idmodality_types, ModalityTypeName FROM modality_types");
cbModalityType.addItem(new comboItem("", -1));
while(result.next()) {
cbModalityType.addItem(new comboItem(result.getString("ModalityTypeName"), result.getInt("idmodality_types")));
}
result = cdb.st.executeQuery("SELECT idevents, EventName FROM events");
cbEvents.addItem(new comboItem("", -1));
while(result.next()) {
cbEvents.addItem(new comboItem(result.getString("EventName"), result.getInt("idevents")));
}
result = cdb.st.executeQuery("SELECT idhardware_items, Name FROM hardware_items");
cbHardwareItem.addItem(new comboItem("", -1));
while(result.next()) {
cbHardwareItem.addItem(new comboItem(result.getString("Name"), result.getInt("idhardware_items")));
}
cdb.st.close();
}
catch( Exception e ) {
e.printStackTrace();
}
}
/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
HardwareItemComponents window = new HardwareItemComponents();
window.frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the application.
*/
public HardwareItemComponents() {
initialize();
getData();
}
/**
* Initialize the contents of the frame.
*/
private void initialize() {
frame = new JFrame();
frame.setBounds(100, 100, 405, 779);
frame.getContentPane().setLayout(null);
JLabel lblHardwareItem = new JLabel("Hardware Item");
lblHardwareItem.setFont(new Font("Calibri", Font.PLAIN, 11));
lblHardwareItem.setBounds(8, 474, 89, 14);
frame.getContentPane().add(lblHardwareItem);
cbHardwareItem.setFont(new Font("Calibri", Font.PLAIN, 11));
cbHardwareItem.setBounds(100, 471, 252, 20);
frame.getContentPane().add(cbHardwareItem);
JLabel lblName = new JLabel("Name");
lblName.setFont(new Font("Calibri", Font.PLAIN, 11));
lblName.setBounds(8, 55, 46, 14);
frame.getContentPane().add(lblName);
txtCompName = new JTextField();
txtCompName.setFont(new Font("Calibri", Font.PLAIN, 11));
txtCompName.setBounds(100, 53, 115, 20);
frame.getContentPane().add(txtCompName);
txtCompName.setColumns(10);
JButton btnAddComponent = new JButton("Add component");
btnAddComponent.setFont(new Font("Calibri", Font.PLAIN, 11));
btnAddComponent.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
ConnectDatabase cdb = new ConnectDatabase();
System.out.println("After Connect Database!");
try {
cdb.st.executeUpdate("INSERT INTO components (Name, ModalityTypeID) VALUES ('"+txtCompName.getText()+"',"+Integer.toString(((comboItem)cbModalityType.getSelectedItem()).value)+ ")");
System.out.println("1 row affected");
} catch (SQLException ex) {
System.out.println("SQL statement is not executed!"+ex);
}
getData();
}
});
btnAddComponent.setBounds(231, 51, 115, 23);
frame.getContentPane().add(btnAddComponent);
JLabel lblComponents_1 = new JLabel("Components:");
lblComponents_1.setFont(new Font("Calibri", Font.BOLD, 12));
lblComponents_1.setBounds(8, 11, 104, 14);
frame.getContentPane().add(lblComponents_1);
JLabel lblStates = new JLabel("States:");
lblStates.setFont(new Font("Calibri", Font.BOLD, 12));
lblStates.setBounds(8, 84, 46, 14);
frame.getContentPane().add(lblStates);
JLabel lblName_1 = new JLabel("Name");
lblName_1.setFont(new Font("Calibri", Font.PLAIN, 11));
lblName_1.setBounds(8, 134, 46, 14);
frame.getContentPane().add(lblName_1);
txtStateName = new JTextField();
txtStateName.setFont(new Font("Calibri", Font.PLAIN, 11));
txtStateName.setBounds(100, 131, 115, 20);
frame.getContentPane().add(txtStateName);
txtStateName.setColumns(10);
JLabel lblComponent = new JLabel("Component");
lblComponent.setFont(new Font("Calibri", Font.PLAIN, 11));
lblComponent.setBounds(8, 109, 89, 14);
frame.getContentPane().add(lblComponent);
JLabel lblTransitions = new JLabel("Transitions:");
lblTransitions.setFont(new Font("Calibri", Font.BOLD, 12));
lblTransitions.setBounds(8, 175, 89, 14);
frame.getContentPane().add(lblTransitions);
txtTransName = new JTextField();
txtTransName.setFont(new Font("Calibri", Font.PLAIN, 11));
txtTransName.setColumns(10);
txtTransName.setBounds(100, 215, 252, 20);
frame.getContentPane().add(txtTransName);
cbEvents.setFont(new Font("Calibri", Font.PLAIN, 11));
cbEvents.setBounds(100, 385, 252, 20);
frame.getContentPane().add(cbEvents);
JLabel label = new JLabel("Event");
label.setFont(new Font("Calibri", Font.PLAIN, 11));
label.setForeground(Color.BLACK);
label.setBounds(8, 388, 28, 14);
frame.getContentPane().add(label);
JLabel label_1 = new JLabel("Action");
label_1.setFont(new Font("Calibri", Font.PLAIN, 11));
label_1.setForeground(Color.BLACK);
label_1.setBounds(8, 344, 30, 12);
frame.getContentPane().add(label_1);
JLabel label_2 = new JLabel("Condition");
label_2.setFont(new Font("Calibri", Font.PLAIN, 11));
label_2.setForeground(Color.BLACK);
label_2.setBounds(8, 302, 82, 12);
frame.getContentPane().add(label_2);
JLabel label_3 = new JLabel("State to");
label_3.setFont(new Font("Calibri", Font.PLAIN, 11));
label_3.setForeground(Color.BLACK);
label_3.setBounds(8, 271, 39, 14);
frame.getContentPane().add(label_3);
JLabel label_4 = new JLabel("State from");
label_4.setFont(new Font("Calibri", Font.PLAIN, 11));
label_4.setForeground(Color.BLACK);
label_4.setBounds(8, 246, 51, 14);
frame.getContentPane().add(label_4);
JLabel label_5 = new JLabel("Name");
label_5.setFont(new Font("Calibri", Font.PLAIN, 11));
label_5.setForeground(Color.BLACK);
label_5.setBounds(8, 221, 82, 14);
frame.getContentPane().add(label_5);
final JTextArea txtCondition = new JTextArea();
txtCondition.setFont(new Font("Calibri", Font.PLAIN, 11));
txtCondition.setBounds(100, 296, 252, 36);
frame.getContentPane().add(txtCondition);
final JTextArea txtAction = new JTextArea();
txtAction.setFont(new Font("Calibri", Font.PLAIN, 13));
txtAction.setBounds(100, 338, 252, 36);
frame.getContentPane().add(txtAction);
JButton btnAddTransition = new JButton("Add Transition");
btnAddTransition.setFont(new Font("Calibri", Font.PLAIN, 11));
btnAddTransition.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ConnectDatabase cdb = new ConnectDatabase();
System.out.println("After Connect Database!");
int StateFromID = ((comboItem)cbStateFrom.getSelectedItem()).value;
int StateToID = ((comboItem)cbStateTo.getSelectedItem()).value;
int EventID = ((comboItem)cbEvents.getSelectedItem()).value;
try {
String Query = "INSERT INTO `test`.`transitions` (`Name`,`StateFrom`,`StateTo`,`Condition`,`Action`,`EventID`) VALUES ('"+txtTransName.getText()+"',"+Integer.toString(StateFromID)+","+Integer.toString(StateToID)+",'"+txtCondition.getText()+"','"+txtAction.getText()+"',"+Integer.toString(EventID)+")";
System.out.println(Query);
cdb.st.executeUpdate(Query);
System.out.println("1 row affected");
} catch (SQLException ex) {
System.out.println("SQL statement is not executed!"+ex);
}
getData();
}
});
btnAddTransition.setBounds(231, 408, 115, 23);
frame.getContentPane().add(btnAddTransition);
JSeparator separator = new JSeparator();
separator.setBounds(18, 79, 328, 2);
frame.getContentPane().add(separator);
JSeparator separator_1 = new JSeparator();
separator_1.setBounds(18, 162, 328, 2);
frame.getContentPane().add(separator_1);
JLabel lblCompo = new JLabel("Component");
lblCompo.setFont(new Font("Calibri", Font.PLAIN, 11));
lblCompo.setBounds(8, 502, 76, 14);
frame.getContentPane().add(lblCompo);
//JTree tree = new JTree();
treePanelHardwareItems = new DynamicTree();
treePanelHardwareItems.setBounds(8, 564, 340, 166);
frame.getContentPane().add(treePanelHardwareItems);
cbHardwareItemComponent.setFont(new Font("Calibri", Font.PLAIN, 11));
cbHardwareItemComponent.setBounds(100, 499, 252, 20);
cbHardwareItem.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent arg0) {
getDataComponentsForHardwareItem();
populateTreeHardwareItems(treePanelHardwareItems);
}
});
frame.getContentPane().add(cbHardwareItemComponent);
JButton btnAdd = new JButton("Add");
btnAdd.setFont(new Font("Calibri", Font.PLAIN, 11));
//btnAdd.setBounds(126, 523, 89, 23);
frame.getContentPane().add(btnAdd);
JSeparator separator_2 = new JSeparator();
separator_2.setBounds(24, 438, 328, 2);
frame.getContentPane().add(separator_2);
JLabel lblCoupling = new JLabel("Coupling of Hardware Item and Components:");
lblCoupling.setFont(new Font("Calibri", Font.BOLD, 12));
lblCoupling.setBounds(8, 448, 259, 14);
frame.getContentPane().add(lblCoupling);
JButton btnAddState = new JButton("Add state");
btnAddState.setFont(new Font("Calibri", Font.PLAIN, 11));
btnAddState.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ConnectDatabase cdb = new ConnectDatabase();
System.out.println("After Connect Database!");
try {
cdb.st.executeUpdate("INSERT INTO comp_states (ComponentID, Name) VALUES ("+Integer.toString(((comboItem)cbComponent.getSelectedItem()).value)+",'"+txtStateName.getText()+"')");
System.out.println("1 row affected state " + txtStateName.getText());
} catch (SQLException ex) {
System.out.println("SQL statement is not executed!"+ex);
}
getData();
}
});
btnAddState.setBounds(231, 130, 115, 23);
frame.getContentPane().add(btnAddState);
cbComponent.setFont(new Font("Calibri", Font.PLAIN, 11));
cbComponent.setBounds(100, 105, 246, 20);
frame.getContentPane().add(cbComponent);
cbStateFrom.setFont(new Font("Calibri", Font.PLAIN, 11));
cbStateFrom.setBounds(100, 244, 252, 20);
frame.getContentPane().add(cbStateFrom);
cbStateTo.setFont(new Font("Calibri", Font.PLAIN, 11));
cbStateTo.setBounds(100, 269, 252, 20);
frame.getContentPane().add(cbStateTo);
JLabel lblComponent_1 = new JLabel("Component");
lblComponent_1.setFont(new Font("Calibri", Font.PLAIN, 11));
lblComponent_1.setBounds(8, 195, 82, 14);
frame.getContentPane().add(lblComponent_1);
cbTransComponents.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent arg0) {
getDataStatesForComponents();
}
});
cbTransComponents.setFont(new Font("Calibri", Font.PLAIN, 11));
cbTransComponents.setBounds(100, 191, 248, 20);
frame.getContentPane().add(cbTransComponents);
JButton btnNewButton = new JButton("Add coupling");
btnNewButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
ConnectDatabase cdb = new ConnectDatabase();
System.out.println("After Connect Database!");
try {
cdb.st.executeUpdate("INSERT INTO hardware_items_components (ComponentID, HardwareItemID) VALUES ("+Integer.toString(((comboItem)cbHardwareItemComponent.getSelectedItem()).value)+","+Integer.toString(((comboItem)cbHardwareItem.getSelectedItem()).value)+")");
System.out.println("1 row affected state ");
} catch (SQLException ex) {
System.out.println("SQL statement is not executed!"+ex);
}
getData();
populateTreeHardwareItems(treePanelHardwareItems);
}
});
btnNewButton.setFont(new Font("Calibri", Font.PLAIN, 11));
btnNewButton.setBounds(231, 530, 115, 23);
frame.getContentPane().add(btnNewButton);
JLabel lblModalityType = new JLabel("Modality type");
lblModalityType.setFont(new Font("Calibri", Font.PLAIN, 11));
lblModalityType.setBounds(8, 30, 76, 14);
frame.getContentPane().add(lblModalityType);
cbModalityType.setFont(new Font("Calibri", Font.PLAIN, 11));
cbModalityType.setBounds(100, 26, 246, 20);
frame.getContentPane().add(cbModalityType);
}
}
| [
"marija59@gmail.com"
] | marija59@gmail.com |
ecf429add1112c18c6b82d97d08427a43981a4c7 | 6e25477f3ab88ce3a924783e51df93678ab0ea3a | /src/main/java/com/moviejukebox/mjbsqldb/dto/CountryDTO.java | a5dfa3aa15f357cbcb5f97bc6d8c7cd825708268 | [] | no_license | Omertron/MovieJukeboxSQLDB | 417658ab85760d017871b7d9be4cd25580217c02 | f6bac62aac0de8cc3c7b18c73c351e7a846684b2 | refs/heads/master | 2020-05-09T21:35:34.977228 | 2015-05-27T06:26:57 | 2015-05-27T06:26:57 | 28,970,455 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,681 | java | /*
* Copyright (c) 2004-2015 YAMJ Members
* http://code.google.com/p/moviejukebox/people/list
*
* This file is part of the Yet Another Movie Jukebox (YAMJ).
*
* The YAMJ is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* YAMJ is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with the YAMJ. If not, see <http://www.gnu.org/licenses/>.
*
* Web: http://code.google.com/p/moviejukebox/
*
*/
package com.moviejukebox.mjbsqldb.dto;
import java.io.Serializable;
import java.sql.ResultSet;
import java.sql.SQLException;
public class CountryDTO implements Serializable {
private static final long serialVersionUID = 1L;
public static final String TABLE_NAME = "COUNTRY";
public static final String TABLE_KEY = "ID";
public static final String CREATE_TABLE = "create table if not exists " + TABLE_NAME +
" (ID integer primary key, COUNTRY text, URL text)";
public static final String INSERT_TABLE = "insert into " + TABLE_NAME +
" (ID, COUNTRY, URL) values (?, ?, ?)";
public static final String DROP_TABLE = "drop table if exists " + TABLE_NAME;
private int id;
private String country;
private String url;
public CountryDTO() {
super();
this.id = 0; // Set to the default of 0 (zero)
}
public CountryDTO(int id, String country, String url) {
super();
this.id = id;
this.country = country;
this.url = url;
}
public void populateDTO(ResultSet rs) throws SQLException {
setId(rs.getInt("ID"));
setCountry(rs.getString("COUNTRY"));
setUrl(rs.getString("URL"));
}
public String getCountry() {
return country;
}
public int getId() {
return id;
}
public String getUrl() {
return url;
}
public void setCountry(String country) {
this.country = country;
}
public void setId(int id) {
this.id = id;
}
public void setUrl(String url) {
this.url = url;
}
@Override
public String toString() {
return "CountryDTO [id=" + id + ", country=" + country + ", url=" + url + "]";
}
}
| [
"Stuart.Boston@Gmail.com"
] | Stuart.Boston@Gmail.com |
bea4621e6d4bdffaf3d41cd1b09046740d279a8f | 2cd70aecb604cefceedad657e684707d34f1328f | /Lecture Codes/Lecture01/Lecture01.java | ac6d501aae4cfb4f2f6c91c8f5207686fb807c14 | [] | no_license | ekef/comp110 | 63013c4fabdce0925e3a7de25bcb96d67ac243e2 | abf9bc14e7a1499107bb43b5c31127d5ef7dbb04 | refs/heads/master | 2021-03-10T02:56:52.792839 | 2020-03-09T13:55:55 | 2020-03-09T13:55:55 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,577 | java | import java.util.Arrays;
/**
* Lecture 1 Source Code
* @author Berk Gokberk
* @since 3.2.2020
*
*/
public class Lecture01 {
/**
* App for Trendyol (comment for main)
* @param args
*/
public static void main(String[] args) {
// good programming practice 1
// always use variables instead of numbers in array creation
int numberOfProducts = 10; // number of products in Trendyol
String[] brand; // Brands in Trendyol
int[] price = new int[numberOfProducts]; // Prices of items in Trendyol app
brand = new String[numberOfProducts];
brand[0] = "Nike";
brand[1] = "Beymen";
brand[2] = "Silk Cashmere";
brand[3] = "LCW";
brand[4] = "Adidas";
brand[5] = "Dutti";
price[0] = 700;
price[1] = 3500;
price[2] = 900;
price[3] = 50;
price[4] = 150;
price[5] = 900;
printInfo(brand, price);
int limit = 800;
String[] cheapProducts = findCheapProducts(brand, price, limit);
System.out.println("\nCheap brands are: " + Arrays.toString(cheapProducts));
//makeDiscount(price, 40);
//System.out.println("\nAfter discount: ");
//printInfo(brand, price);
}
// Old style comments:
// Makes discount in Trendyol products
// It has two inputs:
// inputArray: prices of the products
// discountPrice: discount price in TL
/**
* Makes discount ..... (Javadoc style comments)
* @param inputArray prices of the items ....
* @param discountPrice discount price ....
*/
private static void makeDiscount(int[] inputArray, int discountPrice) {
for (int i = 0; i < inputArray.length; i++)
inputArray[i] -= discountPrice;
}
/**
* Prints product information
* @param brand explanation of the brand
* @param price explanation of the price variable
*/
public static void printInfo(String[] brand, int[] price) {
for (int i = 0; i < price.length; i++)
//System.out.println((i+1) + ". Brand: " + brand[i] + ", Price: " + price[i] + "TL");
if (brand[i] != null)
System.out.printf("%2d. Brand: %-20s Price: %5dTL\n", (i+1), brand[i], price[i] );
}
private static String[] findCheapProducts(String[] inputBrand, int[] inputPrice, int limit) {
int counter = 0;
for (int i = 0; i < inputPrice.length; i++)
if ((inputPrice[i] <= limit) && (inputPrice[i] > 0))
counter++;
//System.out.println("Counter: " + counter);
String[] outputArray = new String[counter];
int k = 0;
for (int i = 0; i < inputBrand.length; i++) {
if ( (inputPrice[i] <= limit) && (inputPrice[i] > 0) ){
outputArray[k] = inputBrand[i];
k = k + 1;
}
}
return outputArray;
}
} | [
"gokberk@gmail.com"
] | gokberk@gmail.com |
35f0c4415f72aec6589e121492439c6f7e9de77c | 67fafa5d845bc84d6b75a607160daf615275b811 | /jgrapht/org/jgrapht/graph/AsUnweightedDirectedGraph.java | d8bd73a7dc2837e7d175cf81a66c46cab829c635 | [] | no_license | lpxz/poplsync | 0d653b809305c153d54f870fa7a3cc03d0d92b8d | 05d91235381b7402d77ff6fadbda15c7ae2b67f4 | refs/heads/master | 2021-01-01T05:30:32.633024 | 2014-04-08T02:39:43 | 2014-04-08T02:39:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,412 | java | /* ==========================================
* JGraphT : a free Java graph-theory library
* ==========================================
*
* Project Info: http://jgrapht.sourceforge.net/
* Project Creator: Barak Naveh (http://sourceforge.net/users/barak_naveh)
*
* (C) Copyright 2003-2008, by Barak Naveh and Contributors.
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
*/
/* ----------------------
* AsUnweightedGraph.java
* ----------------------
* (C) Copyright 2007-2008, by Lucas J. Scharenbroich and Contributors.
*
* Original Author: Lucas J. Scharenbroich
* Contributor(s): John V. Sichi
*
* $Id: AsUnweightedDirectedGraph.java,v 1.1 2009/10/22 15:10:02 charlesz Exp $
*
* Changes
* -------
* 7-Sep-2007 : Initial revision (LJS);
*
*/
package org.jgrapht.graph;
import java.io.*;
import org.jgrapht.*;
/**
* An unweighted view of the backing weighted graph specified in the
* constructor. This graph allows modules to apply algorithms designed for
* unweighted graphs to a weighted graph by simply ignoring edge weights. Query
* operations on this graph "read through" to the backing graph. Vertex
* addition/removal and edge addition/removal are all supported (and immediately
* reflected in the backing graph).
*
* <p>Note that edges returned by this graph's accessors are really just the
* edges of the underlying directed graph.</p>
*
* <p>This graph does <i>not</i> pass the hashCode and equals operations through
* to the backing graph, but relies on <tt>Object</tt>'s <tt>equals</tt> and
* <tt>hashCode</tt> methods. This graph will be serializable if the backing
* graph is serializable.</p>
*
* @author Lucas J. Scharenbroich
* @since Sep 7, 2007
*/
public class AsUnweightedDirectedGraph<V, E>
extends GraphDelegator<V, E>
implements Serializable,
DirectedGraph<V, E>
{
//~ Static fields/initializers ---------------------------------------------
/**
*/
private static final long serialVersionUID = -4320818446777715312L;
//~ Constructors -----------------------------------------------------------
/**
* Constructor for AsUnweightedGraph.
*
* @param g the backing graph over which an unweighted view is to be
* created.
*/
public AsUnweightedDirectedGraph(DirectedGraph<V, E> g)
{
super(g);
}
//~ Methods ----------------------------------------------------------------
/**
* @see Graph#getEdgeWeight
*/
public double getEdgeWeight(E e)
{
return WeightedGraph.DEFAULT_EDGE_WEIGHT;
}
}
// End AsUnweightedDirectedGraph.java
| [
"lpxz@lpxz-ThinkPad-W530.(none)"
] | lpxz@lpxz-ThinkPad-W530.(none) |
9ba8a9404e777cb48689dfd0544b713d822396af | e1ed290004fec4adafec9d9b7654afc6203aa246 | /src/main/java/com/oshacker/design/principle/singleresponsibility/CourseImpl.java | d03c74d2be123de2f0ef2886c5de01a1f510a9a8 | [] | no_license | YuanAaron/design_pattern | 621e3e8895c537165763c1187d7ee86af9dfb95b | 5a5578dd6783757594ed3b65ba9518b80157753d | refs/heads/master | 2021-06-13T23:56:17.918928 | 2019-07-09T12:58:10 | 2019-07-09T12:58:10 | 195,491,598 | 0 | 0 | null | 2021-04-22T18:26:15 | 2019-07-06T03:09:25 | Java | UTF-8 | Java | false | false | 409 | java | package com.oshacker.design.principle.singleresponsibility;
public class CourseImpl implements ICourseInformation,ICourseManagement {
@Override
public String getCourseName() {
return null;
}
@Override
public byte[] getCourseVedio() {
return new byte[0];
}
@Override
public void studyCourse() {
}
@Override
public void refundCourse() {
}
}
| [
"1500438364@qq.com"
] | 1500438364@qq.com |
0e8b69c3b7ae7621252119c5c7e4839035114b27 | 6cac31bfcd4e211e6a2174d492575cc9bb35101c | /IPK_lib/src/org/w3c/dom/svg/SVGAltGlyphDefElement.java | fe7852f97800ffc5780e55c16c5564a4628b4577 | [] | no_license | OpenImageAnalysisGroup/IAP | 2f32a9ee7bd1711b85de60c9e89a75764f6fdb63 | 8997e5ee2be7590db2feb61d5ab7890368501f88 | refs/heads/master | 2021-04-22T12:59:18.167712 | 2020-07-14T07:44:00 | 2020-07-14T07:44:00 | 55,412,991 | 18 | 4 | null | null | null | null | UTF-8 | Java | false | false | 92 | java | package org.w3c.dom.svg;
public interface SVGAltGlyphDefElement extends
SVGElement {}
| [
"cklukas@users.noreply.github.com"
] | cklukas@users.noreply.github.com |
bb0e4160a8855d7dc513ef792fd6d991760b109c | 27d3c58e3229bcf0efc64855f9a8db92f3b5fe83 | /MaddenThreadPool/src/maddenthreadpool/EchoClient.java | 15f2d0e5db619b013a7fc23de0859b893e7219c9 | [] | no_license | jfmads/ThreadPool | a209ce6aff07b552f29c53435e5343c103675260 | 1726fc2617f7d3e57f868e36e13c41aa5897d48b | refs/heads/master | 2020-05-15T06:06:47.517911 | 2019-04-18T16:02:30 | 2019-04-18T16:02:30 | 182,117,711 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,534 | java | package maddenthreadpool;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.NoSuchElementException;
import java.util.Scanner;
/**
* @author Joseph Madden
* Date Created : 04/05/2019
* Date Modified: 04/12/2019
*/
public class EchoClient {
public static void main(String[] args) throws IOException {
System.out.println("CLIENT STARTING");
final String HOST = "127.0.0.1";
String clientInput;
Scanner inClient = new Scanner(System.in); // reads in a line of text from the keyboard
try (Socket clientSocket = new Socket(HOST, EchoServer.PORT)) { // tries to open connection on local host
System.out.println("CLIENT CONNECTED");
PrintWriter serverOut = new PrintWriter(clientSocket.getOutputStream(), true); // output stream to server
Scanner serverInput = new Scanner(clientSocket.getInputStream());
while(true){
System.out.print("Client: ");
clientInput = inClient.nextLine(); // stores client input into a variable
if(clientInput.equals(".")) // while client input != period
break;
serverOut.println(clientInput); // writes to the client input to server
System.out.println(serverInput.nextLine()); // writes server response to console
}
System.out.println("Client done.");
} catch (NoSuchElementException e) {
}
}
}
| [
"48923144+jfmads@users.noreply.github.com"
] | 48923144+jfmads@users.noreply.github.com |
bb657451ea58208490642561896bf1013dbff4cb | 908b9859a4b45dca4d916720122a1b40c0fafe43 | /labs/wsclient/src/main/java/com/mt/pos/dto/WelcomeDTO.java | 83afe015b0c55336159873c5917d2625b520f29d | [] | no_license | mugabarigiraCHUK/scotomax-hman | 778a3b48c9ac737414beaee9d72d1138a1e5b1ee | 786478731338b5af7a86cada2e4582ddb3b2569f | refs/heads/master | 2021-01-10T06:50:26.179698 | 2012-08-13T16:35:46 | 2012-08-13T16:35:46 | 46,422,699 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,338 | java | package com.mt.pos.dto;
import com.mt.pos.ws.beans.SidType;
import com.mt.pos.ws.beans.TariffPlan;
import java.io.Serializable;
import java.util.List;
import javax.faces.model.SelectItem;
public abstract class WelcomeDTO implements Serializable {
/**
*
*/
private static final long serialVersionUID = 4859041937108523747L;
protected String userCode;
protected String pinCode;
protected String companyId;
protected String notifyMessage;
protected List<SidType> dtSidType;
protected List<TariffPlan> dtTariffPlan;
protected List<SelectItem> selectionDeviceBrands;
protected String selectedDeviceBrand;
protected List<SelectItem> selectionDeviceModels;
protected List<SelectItem> selectionSimAppGroups;
protected String selectedSimAppGroup;
protected List<SelectItem> selectionSimApplications;
protected String simIccId;
protected Integer idProfile;
protected Long availableMemory;
protected Long totalMemory;
protected void clear() {
userCode = null;
pinCode = null;
companyId = null;
notifyMessage = null;
selectionDeviceBrands = null;
selectionDeviceModels = null;
selectionSimAppGroups = null;
selectionSimApplications = null;
}
public String getUserCode() {
return userCode;
}
public void setUserCode(String userCode) {
this.userCode = userCode;
}
public String getPinCode() {
return pinCode;
}
public void setPinCode(String pinCode) {
this.pinCode = pinCode;
}
public String getCompanyId() {
return companyId;
}
public void setCompanyId(String companyId) {
this.companyId = companyId;
}
public String getNotifyMessage() {
return notifyMessage;
}
public void setNotifyMessage(String notifyMessage) {
this.notifyMessage = notifyMessage;
}
public List<SelectItem> getSelectionDeviceBrands() {
return selectionDeviceBrands;
}
public void setSelectionDeviceBrands(List<SelectItem> selectionDeviceBrands) {
this.selectionDeviceBrands = selectionDeviceBrands;
}
public List<SelectItem> getSelectionDeviceModels() {
return selectionDeviceModels;
}
public void setSelectionDeviceModels(List<SelectItem> selectionDeviceModels) {
this.selectionDeviceModels = selectionDeviceModels;
}
public List<SelectItem> getSelectionSimAppGroups() {
return selectionSimAppGroups;
}
public void setSelectionSimAppGroups(List<SelectItem> selectionSimAppGroups) {
this.selectionSimAppGroups = selectionSimAppGroups;
}
public List<SelectItem> getSelectionSimApplications() {
return selectionSimApplications;
}
public void setSelectionSimApplications(List<SelectItem> selectionSimApplications) {
this.selectionSimApplications = selectionSimApplications;
}
public List<SidType> getDtSidType() {
return dtSidType;
}
public void setDtSidType(List<SidType> dtSidType) {
this.dtSidType = dtSidType;
}
public List<TariffPlan> getDtTariffPlan() {
return dtTariffPlan;
}
public void setDtTariffPlan(List<TariffPlan> dtTariffPlan) {
this.dtTariffPlan = dtTariffPlan;
}
public String getSelectedDeviceBrand() {
return selectedDeviceBrand;
}
public void setSelectedDeviceBrand(String selectedDeviceBrand) {
this.selectedDeviceBrand = selectedDeviceBrand;
}
public String getSelectedSimAppGroup() {
return selectedSimAppGroup;
}
public void setSelectedSimAppGroup(String selectedSimAppGroup) {
this.selectedSimAppGroup = selectedSimAppGroup;
}
public Long getAvailableMemory() {
return availableMemory;
}
public void setAvailableMemory(Long availableMemory) {
this.availableMemory = availableMemory;
}
public Integer getIdProfile() {
return idProfile;
}
public void setIdProfile(Integer idProfile) {
this.idProfile = idProfile;
}
public String getSimIccId() {
return simIccId;
}
public void setSimIccId(String simIccId) {
this.simIccId = simIccId;
}
public Long getTotalMemory() {
return totalMemory;
}
public void setTotalMemory(Long totalMemory) {
this.totalMemory = totalMemory;
}
}
| [
"developmax@ad344d4b-5b83-fe1d-98cd-db9ebd70f650"
] | developmax@ad344d4b-5b83-fe1d-98cd-db9ebd70f650 |
e27e61ccbf933a0519ac8acc87e048457d65acd9 | 26b7f30c6640b8017a06786e4a2414ad8a4d71dd | /src/number_of_direct_superinterfaces/i52030.java | 089378aa9a82bb36b7c1cb591736374f1ed1a29a | [] | no_license | vincentclee/jvm-limits | b72a2f2dcc18caa458f1e77924221d585f23316b | 2fd1c26d1f7984ea8163bc103ad14b6d72282281 | refs/heads/master | 2020-05-18T11:18:41.711400 | 2014-09-14T04:25:18 | 2014-09-14T04:25:18 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 69 | java | package number_of_direct_superinterfaces;
public interface i52030 {} | [
"vincentlee.dolbydigital@yahoo.com"
] | vincentlee.dolbydigital@yahoo.com |
482c71189b9defdbbf1a94010f6089a821eae844 | a6ab51ffcb04934a7f531d56ce99b8a535cc2174 | /code/Starter/src/monitor/ProzessIdsHelper.java | d3ca2d5f2df05b6daf68bda6c55b64a454333ac1 | [] | no_license | katezilla/vs-a2 | 27fce9fee3056363c190076c160155634a5c8355 | 16970de46fdecc1b958127830591220a70ff080c | refs/heads/master | 2020-12-24T14:52:43.992307 | 2015-06-02T09:20:42 | 2015-06-02T09:20:42 | 34,451,619 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,673 | java | package monitor;
/**
* monitor/ProzessIdsHelper.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from monitor.idl
* Montag, 4. Mai 2015 21:58 Uhr MESZ
*/
abstract public class ProzessIdsHelper
{
private static String _id = "IDL:monitor/ProzessIds:1.0";
public static void insert (org.omg.CORBA.Any a, String[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static String[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().create_string_tc (0);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (monitor.ProzessIdsHelper.id (), "ProzessIds", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static String[] read (org.omg.CORBA.portable.InputStream istream)
{
String value[] = null;
int _len0 = istream.read_long ();
value = new String[_len0];
for (int _o1 = 0;_o1 < value.length; ++_o1)
value[_o1] = istream.read_string ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, String[] value)
{
ostream.write_long (value.length);
for (int _i0 = 0;_i0 < value.length; ++_i0)
ostream.write_string (value[_i0]);
}
}
| [
"jannik.iacobi@haw-hamburg.de"
] | jannik.iacobi@haw-hamburg.de |
6a921ca6afb932f7aa6b950374bf7e9f3c8c004c | aa4c9a86bc89ed49a38f2f3def9349e413c08907 | /src/main/java/cn/itcast/tsetee.java | f63dc64c861e894266e3caba608d72f2a023e51d | [] | no_license | 1095742713/demo | 8d7115d097033609e7565d3da1079becbd1875fb | e361429316ded915d66b515b4f7491a26ed24201 | refs/heads/master | 2022-07-07T13:15:20.651681 | 2020-03-22T13:58:15 | 2020-03-22T13:58:15 | 223,140,047 | 0 | 0 | null | 2022-06-29T17:47:41 | 2019-11-21T09:43:54 | Java | UTF-8 | Java | false | false | 911 | java | package cn.itcast;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class tsetee {
public static void main(String[] args) throws Exception {
//ๅๅปบxxsf
Workbook wb = new XSSFWorkbook();
//ๅๅปบๅทฅไฝ็ฐฟ
Sheet sheet = wb.createSheet();
//ๅจๅชไธ่ก
Row row = sheet.createRow(1);
//ๅจ้ฃไธชๅๅ
ๆ ผ
Cell cell = row.createCell(773);
//ๅจๅๅ
ๆ ผไธญ่ฎพ็ฝฎๅผ
cell.setCellValue("wdafafๅผ ไธ");
File file = new File("D:/w/a.xlsx");
FileOutputStream pis = new FileOutputStream(file);
wb.write(pis);
pis.close();
}
}
| [
"1095742713@qq.com"
] | 1095742713@qq.com |
655b5da210b07390b0972f41cf76405a8179663f | ee09dd36a9ef18f97d632f29d8a54d5381bb18fd | /src/com/action/Do_Move.java | c09a35368cf353a64f4bf88d0af84be60528a1d4 | [] | no_license | bababoom/AEIM | eb5e064fca186752db52492e6196a3f9e51b35fb | 66a7fe09ae6ad055b7c35799bcb7ec593cdc2e71 | refs/heads/master | 2020-03-10T05:43:27.991064 | 2018-04-12T12:23:01 | 2018-04-12T12:23:01 | 129,223,736 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,143 | java | package com.action;
import java.sql.ResultSet;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import Data.Data_con;
import com.opensymphony.xwork2.Action;
public class Do_Move implements Action {
private Data_con con = new Data_con() ;
private String E_list ;
private String D_list ;
private String tip ;
private String JOB ;
@Override
public String execute() throws Exception {
// TODO Auto-generated method stub
Date date = new Date() ;
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
String str = df.format(date) ;
String[] E = this.getE_list().split(" - ") ;
String[] D = this.getD_list().split(" - ") ;
String[] front = new String[2] ;
String sql = "select DEPTNO,JOB from emp where EMPNO='"+E[0]+"'" ;
ResultSet rs = con.getStat().executeQuery(sql) ;
while(rs.next()){
front[0] = rs.getString("DEPTNO") ;
front[1] = rs.getString("JOB") ;
}
String sql1 ="" ;
if(!this.getJOB().trim().equals("")){
sql = "insert into move(EMPNO,ENAME,FRONT_DEPTNO,AFTER_DEPTNO,MOVEDATE,FRONT_JOB,AFTER_JOB,TIP) values('"+E[0]+"','"+E[1]+"','"+front[0]+"','"+
D[0]+"','"+str+"','"+front[1]+"','"+this.getJOB()+"','"+this.getTip()+"')";
sql1 = "update emp set DEPTNO = '"+D[0]+"',JOB='"+this.getJOB().trim()+"' where EMPNO='"+E[0]+"'" ;
}else{
sql = "insert into move(EMPNO,ENAME,FRONT_DEPTNO,AFTER_DEPTNO,MOVEDATE,FRONT_JOB,AFTER_JOB,TIP) values('"+E[0]+"','"+E[1]+"','"+front[0]+"','"+
D[0]+"','"+str+"','"+front[1]+"','"+front[1]+"','"+this.getTip()+"')";
sql1 = "update emp set DEPTNO = '"+D[0]+"' where EMPNO='"+E[0]+"'" ;
}
con.getStat().execute(sql) ;
con.getStat().execute(sql1) ;
return SUCCESS ;
}
public String getE_list() {
return E_list;
}
public void setE_list(String e_list) {
E_list = e_list;
}
public String getD_list() {
return D_list;
}
public void setD_list(String d_list) {
D_list = d_list;
}
public String getTip() {
return tip;
}
public void setTip(String tip) {
this.tip = tip;
}
public String getJOB() {
return JOB;
}
public void setJOB(String jOB) {
JOB = jOB;
}
}
| [
"13132512292@163.com"
] | 13132512292@163.com |
d96bf5feca84c6835a86d0a482d0cddb1f215b63 | 32b541f9e2acb81033b77d32d60a83e6c10a4d9f | /Java 8/JavaExercise/src/ExamThree/Factorials.java | 7adc1ec923a93859c1b77632064547d273e91fdb | [] | no_license | mortozafsti/Java-SE-8 | 4c81da201a71cb3181c94a87f84cd4770dfca8dc | d95cd2bdca087e89d4ec7eedcd6ba5b0387fa30d | refs/heads/master | 2021-07-19T17:35:21.535803 | 2018-12-07T06:57:30 | 2018-12-07T06:57:30 | 146,238,654 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 416 | java |
package ExamThree;
import java.util.Scanner;
public class Factorials {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter the Number: ");
int dd = sc.nextInt();
int i,fact=1;
for (i = 1; i <=dd; i++) {
fact = fact*i;
}
System.out.println("Factorial of "+dd+" is "+fact);
}
}
| [
"mortozafsti@gmail.com"
] | mortozafsti@gmail.com |
73d08332924ad20006dc8f7185231e5446409ab5 | e0b8a589aa82972ba16c063af52cad42236af4db | /U10E3/src/crf/android/contact/ContactActivity.java | 5b173ad935b4783349c42a2280dbbe77fd0d505b | [] | no_license | alfonbass/CRF | e72541361acc82167f969a3db399688f7c167334 | 44b96d68c2302f9c7310f00cd110008b6bd748a1 | refs/heads/master | 2016-09-06T12:40:42.456982 | 2012-08-31T16:57:03 | 2012-08-31T16:57:03 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,425 | java | package crf.android.contact;
import android.app.ListActivity;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.view.View;
import android.widget.ListView;
import android.widget.SimpleCursorAdapter;
import android.widget.Toast;
public class ContactActivity extends ListActivity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.list);
String[] projection=new String[] {Phone._ID, Phone.DISPLAY_NAME, Phone.NUMBER};
//String filtro=Phone.DISPLAY_NAME+" LIKE ?"; Filtro posible
Cursor cursor=getContentResolver().query(
ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
projection,
null, null,
Phone.DISPLAY_NAME+" ASC");
startManagingCursor(cursor);
String[] from=new String[]{ Phone.DISPLAY_NAME, Phone.NUMBER};
int[] to=new int[]{ R.id.name, R.id.telefono};
SimpleCursorAdapter adapter=new SimpleCursorAdapter(this, R.layout.main, cursor, from, to);
this.setListAdapter(adapter);
}
protected void onListItemClick(ListView l, View v, int position, long id) {
super.onListItemClick(l, v, position, id);
Cursor c = ((Cursor) l.getAdapter().getItem(position));
Toast.makeText(getBaseContext(), c.getString(c.getColumnIndex(Phone.DISPLAY_NAME)), Toast.LENGTH_LONG).show();
}
} | [
"alfonbass@gmail.com"
] | alfonbass@gmail.com |
15c6463c51279f8ad38afbbc71e490108300cfff | 1acb38f5067494c3565700ab231e1fd2a4972876 | /src/main/java/cn/zhanghui/myspring/beanfactory_annotation2/config/ConfigurableBeanFactory.java | 4ee8e2135e42d1e89fa8a6c5d701540f937a1051 | [] | no_license | 2550462328/my-spring | 5e72da1025c30249f27006ea58da98bedca1539e | 8bac00566d2e184d79b0e229c2c5466d29a2985b | refs/heads/master | 2023-01-05T16:11:22.161531 | 2020-11-02T03:53:01 | 2020-11-02T03:53:01 | 308,571,926 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 697 | java | package cn.zhanghui.myspring.beanfactory_annotation2.config;
import java.util.List;
import cn.zhanghui.myspring.beanfactory_annotation2.BeanFactory;
/**
* @ClassName: ConfigurableBeanFactory.java
* @Description: ไธบclassPathResource้
็ฝฎClassLoader
* @author: ZhangHui
* @date: 2019ๅนด10ๆ25ๆฅ ไธๅ4:09:40
*/
public interface ConfigurableBeanFactory extends BeanFactory{
void setClassLoader(ClassLoader cl);
ClassLoader getClassLoader();
//ๅ ไธบBeanPostProcessorๅฏ่ฝไธๆญขไธไธช๏ผๅจๆไปฌๅญฆไน ไธญๅชๆฏ้
็ฝฎAutowired็ๆ
ๅฝข๏ผ๏ผๆไปฅ้่ฆ่ฟ่ก้
็ฝฎ
void addBeanPostProcessor(BeanPostProcessor postProcessor);
List<BeanPostProcessor> getBeanPostProcessor();
}
| [
"zhanghui1@epsoft.com.cn"
] | zhanghui1@epsoft.com.cn |
f945eee0320f1984c1d9ce2fd739bc0b991a176d | 1cf15e930761f9bdd3a02e81857d49518ebd820b | /src/main/java/com/example/demo/service/TodoService.java | 57b080f804fcd2aaed109c0e0370f0142496f504 | [] | no_license | eswarijayakumar/Spring-Boot-Todo-Rest-API | 4ce482e9f8d711470769434fe4c01d22c9af1343 | cd7118491b6af528516a1558ff617a86d53e7179 | refs/heads/master | 2022-06-18T19:56:34.590719 | 2020-05-10T10:26:16 | 2020-05-10T10:26:16 | 262,760,920 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 545 | java | package com.example.demo.service;
import com.example.demo.entity.TodoEntity;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Created by eswari-3920 on 5/10/2020
*/
@Component
public interface TodoService {
public List<TodoEntity> retrieveTodos();
public void saveTodoInfo(TodoEntity todoEntity);
public void deleteTodoInfo(Long todoId);
public void updateTodoInfo(TodoEntity todoEntity);
public TodoEntity getTodo(Long todoId);
public TodoEntity getTodoByName(String todoName);
}
| [
"eswari.j@zohocorp.com"
] | eswari.j@zohocorp.com |
0884e85295236b3971bf2f1a3438394b790e5507 | 413e6d2e2bc70ed668417543dc2ab1dbe3b2eebb | /src/main/java/com/aaron/thread/demo/CountDownLatchDemo.java | a68ff7ccb6e7dcb4e36ba8312aece0be41f1030d | [] | no_license | nowhatever/spittr | b60dfac692f2369f42026ec078f47c5b0335b5e3 | bf3a8252ad0955eb23e5e240554bbff317ea72fb | refs/heads/master | 2020-05-16T23:17:51.140121 | 2014-08-19T10:01:08 | 2014-08-19T10:01:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,947 | java | package com.aaron.thread.demo;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* ๆจกๆ้กน็ฎ็ๅผๅ๏ผๅชๆๅฝๆฏไธชๆจกๅ้ฝๅฎๆๅ๏ผ้กน็ฎๆๅฎๆ ๆฏไธชๆจกๅ็็จๆถไธๅ
* CountDownLatch็ไฝฟ็จ็คบไพ
* @author ๅฐe
*
* 2010-4-30 ไธๅ07:41:37
*/
class Module implements Runnable {
private CountDownLatch latch;
private String moduleName;
private int time;// ็จๆถ
public Module(CountDownLatch latch, String moduleName, int time) {
super();
this.latch = latch;
this.moduleName = moduleName;
this.time = time;
}
public void run() {
try {
work();
latch.countDown();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void work() throws InterruptedException {
TimeUnit.MILLISECONDS.sleep(time);
System.out.println(moduleName + " ๅฎๆ๏ผ่ๆถ:" + time);
}
}
class Controller implements Runnable {
private CountDownLatch latch;
public Controller(CountDownLatch latch) {
super();
this.latch = latch;
}
public void run() {
try {
latch.await();
System.out.println("ๆๆๆจกๅ้ฝๅฎๆ๏ผไปปๅกๅฎๆ");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public class CountDownLatchDemo {
static final int SIZE = 20;
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(SIZE);
Random r = new Random();
ExecutorService exec = Executors.newCachedThreadPool();
Controller controller = new Controller(latch);
exec.execute(controller);
for (int i = 0; i < SIZE; i++) {
exec.execute(new Module(latch, "ๆจกๅ" + (i + 1), r.nextInt(2000)));
}
exec.shutdown();
}
}
| [
"aaron_26@163.com"
] | aaron_26@163.com |
f439bee80eba2d46f3fd8c3f36eea3cbb2bfe872 | df80dc30eafa5e5d1542b37e3cd8c2af857fee4f | /ALaCarte/src/com/example/staggeredgridviewdemo/AbstractActivity.java | 433fc063a1ef5e77b5cc28d53db39986c0c74c4c | [] | no_license | khdb/alacarte | 74e51223c2fcdc82719b798435c56ece8a9ae8d0 | 1d3e0865ed167f2368aff9471fa23e345e2cad78 | refs/heads/master | 2020-05-26T06:54:53.698430 | 2013-12-28T12:23:47 | 2013-12-28T12:23:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,214 | java | package com.example.staggeredgridviewdemo;
import java.io.File;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import org.json.JSONException;
import org.json.JSONObject;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.content.DialogInterface;
import android.content.Intent;
import android.nfc.NfcAdapter;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.widget.Toast;
public abstract class AbstractActivity extends Activity {
protected NfcAdapter mAdapter;
protected PendingIntent mPendingIntent;
protected AlertDialog mDialog;
protected String nfcid;
public static String CUSTOM_ACTION = "com.example.staggeredgridviewdemo.OPEN_VIEW";
private static final int ACTION_PREFS = -1;
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
mDialog = new AlertDialog.Builder(this).setNeutralButton("Ok", null)
.create();
mAdapter = NfcAdapter.getDefaultAdapter(this);
if (mAdapter == null) {
showMessage(R.string.error, R.string.no_nfc);
finish();
return;
}
mPendingIntent = PendingIntent.getActivity(this, 0, new Intent(this,
getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
Log.i("Huy", "on save instance state of Abstract");
outState.putString("nfcid", nfcid);
};
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
Log.i("Huy", "on restore instance state of Abstract");
nfcid = savedInstanceState.getString("nfcid");
};
@Override
protected void onResume() {
super.onResume();
if (mAdapter != null) {
if (!mAdapter.isEnabled()) {
showWirelessSettingsDialog();
}
mAdapter.enableForegroundDispatch(this, mPendingIntent, null, null);
}
};
@Override
protected void onPause() {
super.onPause();
if (mAdapter != null) {
mAdapter.disableForegroundDispatch(this);
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// TODO Auto-generated method stub
setIntent(data);
switch (requestCode) {
case ACTION_PREFS: {
Log.i("Huy", "ACTION_PREFS return");
break;
}
}
}
protected void showMessage(int title, int message) {
mDialog.setTitle(title);
mDialog.setMessage(getText(message));
mDialog.show();
}
protected void showWirelessSettingsDialog() {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage(R.string.nfc_disabled);
builder.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialogInterface, int i) {
Intent intent = new Intent(
Settings.ACTION_WIRELESS_SETTINGS);
startActivity(intent);
}
});
builder.setNegativeButton(android.R.string.cancel,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialogInterface, int i) {
finish();
}
});
builder.create().show();
return;
}
@Override
public void onNewIntent(Intent intent) {
nfcid = "";
Log.d("Huy", "on new intent: " + intent.getAction());
boolean isPush = true;
if (intent.hasExtra("com.parse.Channel")
&& intent.hasExtra("com.parse.Data")) {
try {
String action = intent.getAction();
String channel = intent.getExtras().getString(
"com.parse.Channel");
JSONObject json = new JSONObject(intent.getExtras().getString(
"com.parse.Data"));
nfcid = json.getString("nfcid");
Log.d("Huy", "got action " + action + " on channel " + channel
+ " with: nfcid = " + nfcid);
isPush = false;
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(intent.getAction())) {
nfcid = this.ByteArrayToHexString(intent
.getByteArrayExtra(NfcAdapter.EXTRA_ID));
Log.i("Huy", "NDEF DISCOVERED = " + nfcid);
} else if (NfcAdapter.ACTION_TAG_DISCOVERED.equals(intent.getAction())) {
nfcid = this.ByteArrayToHexString(intent
.getByteArrayExtra(NfcAdapter.EXTRA_ID));
Log.i("Huy", "TAG DISCOVERED = " + nfcid);
} else if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(intent.getAction())) {
nfcid = this.ByteArrayToHexString(getIntent().getByteArrayExtra(
NfcAdapter.EXTRA_ID));
Log.i("Huy", "TECH DISCOVERED = " + nfcid);
}
setIntent(intent);
processNfcID(isPush);
// resolveIntent(intent);
}
private String ByteArrayToHexString(byte[] inarray) {
int i, j, in;
String[] hex = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A",
"B", "C", "D", "E", "F" };
String out = "";
for (j = 0; j < inarray.length; ++j) {
in = (int) inarray[j] & 0xff;
i = (in >> 4) & 0x0f;
out += hex[i];
i = in & 0x0f;
out += hex[i];
}
return out;
}
protected abstract void processNfcID(boolean isPush);
}
| [
"thanhhuy89vn@gmail.com"
] | thanhhuy89vn@gmail.com |
4e39b14f3dcb81befd5556de98f5a770ebdf7130 | 2eb84c8cb8f0899b5c7aae041c92d6ce641bc920 | /app/src/main/java/com/example/shafy/moviesguy/utilities/BitmapUtils.java | da620b76c8a4eecea9a3ba1f3e648cb5a4a93b47 | [] | no_license | minacod/MoviesGuy | 7e9a618834394ae44138ed84aaf9666d94099cab | 604baa18ce30572826e6e530dd02850a01ed7780 | refs/heads/master | 2021-07-20T13:04:04.206915 | 2017-10-26T01:58:40 | 2017-10-26T01:58:40 | 104,953,709 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 667 | java | package com.example.shafy.moviesguy.utilities;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import java.io.ByteArrayOutputStream;
/**
* Created by shafy on 25/10/2017.
*/
public class BitmapUtils {
// convert from bitmap to byte array
public static byte[] getBytes(Bitmap bitmap) {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 0, stream);
return stream.toByteArray();
}
// convert from byte array to bitmap
public static Bitmap getImage(byte[] image) {
return BitmapFactory.decodeByteArray(image, 0, image.length);
}
}
| [
"minacod@gmail.com"
] | minacod@gmail.com |
7554434c962f3cb62e46e0ea0f75360c97763d49 | 44e28ebfa9131d9ef49f9ffaa1b003267691a510 | /api/src/com/kamilachyla/bggen/api/Rect.java | 7e7153ce5652d6c358b02c75e61e165c5f2c5614 | [] | no_license | kamchy/java-9-modules-example | 5187a905b589a23b42c75b2335ac033533bb9cc2 | 253fb3d024d27bb12308fcc6db70ff01e3cc1eb8 | refs/heads/main | 2023-06-10T00:49:25.374004 | 2021-06-27T12:13:01 | 2021-06-27T12:13:01 | 337,692,887 | 1 | 0 | null | 2021-06-27T06:57:01 | 2021-02-10T10:44:28 | Java | UTF-8 | Java | false | false | 1,583 | java | package com.kamilachyla.bggen.api;
import java.util.Objects;
import java.util.StringJoiner;
public final class Rect {
private final double x;
private final double y;
private final double width;
private final double height;
public static Rect from(double x, double y, double width, double height) {
return new Rect(x, y, width, height);
}
private Rect(double x, double y, double width, double height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Rect rect = (Rect) o;
return Double.compare(rect.x, x) == 0 &&
Double.compare(rect.y, y) == 0 &&
Double.compare(rect.width, width) == 0 &&
Double.compare(rect.height, height) == 0;
}
@Override
public int hashCode() {
return Objects.hash(x, y, width, height);
}
@Override
public String toString() {
return new StringJoiner(", ", Rect.class.getSimpleName() + "[", "]")
.add("x=" + x)
.add("y=" + y)
.add("width=" + width)
.add("height=" + height)
.toString();
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getWidth() {
return width;
}
public double getHeight() {
return height;
}
}
| [
"kamila.chyla@gmail.com"
] | kamila.chyla@gmail.com |
114c610fdcabb40699676d9c5191b965ad531f12 | a97f5af1a8eebec33b135be6a8236702f518d3c3 | /src/main/java/com/diviso/graeshoppe/payment/aop/logging/LoggingAspect.java | 9409bdaa7bfdc2397cd21066c856509c4de0cf1e | [] | no_license | neerajamurali094/payment-1 | c0d651933883691410306368578fccad6be85395 | b787864439cc5ebd76312f493ba3c9f8f26bc71a | refs/heads/master | 2020-11-25T17:38:37.179196 | 2019-12-10T10:01:24 | 2019-12-10T10:01:24 | 228,776,599 | 0 | 0 | null | 2019-12-18T06:48:51 | 2019-12-18T06:48:51 | null | UTF-8 | Java | false | false | 3,866 | java | package com.diviso.graeshoppe.payment.aop.logging;
import io.github.jhipster.config.JHipsterConstants;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.env.Environment;
import java.util.Arrays;
/**
* Aspect for logging execution of service and repository Spring components.
*
* By default, it only runs with the "dev" profile.
*/
@Aspect
public class LoggingAspect {
private final Logger log = LoggerFactory.getLogger(this.getClass());
private final Environment env;
public LoggingAspect(Environment env) {
this.env = env;
}
/**
* Pointcut that matches all repositories, services and Web REST endpoints.
*/
@Pointcut("within(@org.springframework.stereotype.Repository *)" +
" || within(@org.springframework.stereotype.Service *)" +
" || within(@org.springframework.web.bind.annotation.RestController *)")
public void springBeanPointcut() {
// Method is empty as this is just a Pointcut, the implementations are in the advices.
}
/**
* Pointcut that matches all Spring beans in the application's main packages.
*/
@Pointcut("within(com.diviso.graeshoppe.payment.repository..*)"+
" || within(com.diviso.graeshoppe.payment.service..*)"+
" || within(com.diviso.graeshoppe.payment.web.rest..*)")
public void applicationPackagePointcut() {
// Method is empty as this is just a Pointcut, the implementations are in the advices.
}
/**
* Advice that logs methods throwing exceptions.
*
* @param joinPoint join point for advice
* @param e exception
*/
@AfterThrowing(pointcut = "applicationPackagePointcut() && springBeanPointcut()", throwing = "e")
public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
if (env.acceptsProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)) {
log.error("Exception in {}.{}() with cause = \'{}\' and exception = \'{}\'", joinPoint.getSignature().getDeclaringTypeName(),
joinPoint.getSignature().getName(), e.getCause() != null? e.getCause() : "NULL", e.getMessage(), e);
} else {
log.error("Exception in {}.{}() with cause = {}", joinPoint.getSignature().getDeclaringTypeName(),
joinPoint.getSignature().getName(), e.getCause() != null? e.getCause() : "NULL");
}
}
/**
* Advice that logs when a method is entered and exited.
*
* @param joinPoint join point for advice
* @return result
* @throws Throwable throws IllegalArgumentException
*/
@Around("applicationPackagePointcut() && springBeanPointcut()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
if (log.isDebugEnabled()) {
log.debug("Enter: {}.{}() with argument[s] = {}", joinPoint.getSignature().getDeclaringTypeName(),
joinPoint.getSignature().getName(), Arrays.toString(joinPoint.getArgs()));
}
try {
Object result = joinPoint.proceed();
if (log.isDebugEnabled()) {
log.debug("Exit: {}.{}() with result = {}", joinPoint.getSignature().getDeclaringTypeName(),
joinPoint.getSignature().getName(), result);
}
return result;
} catch (IllegalArgumentException e) {
log.error("Illegal argument: {} in {}.{}()", Arrays.toString(joinPoint.getArgs()),
joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
throw e;
}
}
}
| [
"abilash.s@lxisoft.com"
] | abilash.s@lxisoft.com |
1aae66921a32062a8cdf51180cb1d968071a7eb6 | 6e453d50898b8272e4a5981dfaf4d1399af0ccc9 | /src/test/java/ru/sadv1r/idea/plugin/ansible/vault/editor/intention/PropertyVaultChangePasswordIntentionActionTest.java | b8d2b78cb81010d3981b09eda843811930b9a9c9 | [
"MIT"
] | permissive | wheelerlaw/ansible-vault-editor-idea-plugin | 4c2e0c16478052fffde3357eabe5633064a135d1 | 27610bdb88b97aff640f50c9c0aac14a4b230cfa | refs/heads/master | 2023-06-08T05:28:31.389017 | 2021-07-04T16:46:46 | 2021-07-04T16:46:46 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 533 | java | package ru.sadv1r.idea.plugin.ansible.vault.editor.intention;
import ru.sadv1r.idea.plugin.ansible.vault.editor.LightAnsibleVaultCodeInsightTestCase;
public class PropertyVaultChangePasswordIntentionActionTest extends LightAnsibleVaultCodeInsightTestCase {
@Override
protected String getDataPath() {
return "propertyVaultModifyIntentionAction";
}
@Override
protected String intentionName() {
return "Change vault value password";
}
public void test() {
doAllTests();
}
}
| [
"sadv1r@users.noreply.github.com"
] | sadv1r@users.noreply.github.com |
8ce60525225fa120b49cb3335a0ce099d7dc9354 | 6fa79a0d76261a1fbb153b513e7aa6e6b03714d6 | /ZullServer/src/main/java/com/zull/ZullServer/filters/ErrorFilter.java | f4d813639d552cbfc4b55a04e30456e600d2ac16 | [] | no_license | karan-singh90/SpringCloud | d5e70c8e9fc46ecdd54bdf9c323b5501c627a4e8 | ebcf1ffa70e5daac57c71f2fb83baaf73761b790 | refs/heads/master | 2021-05-20T04:08:16.035005 | 2020-04-01T13:33:51 | 2020-04-01T13:33:51 | 252,178,398 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 535 | java | package com.zull.ZullServer.filters;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.exception.ZuulException;
public class ErrorFilter extends ZuulFilter {
@Override
public String filterType() {
return "error";
}
@Override
public int filterOrder() {
return 0;
}
@Override
public boolean shouldFilter() {
return true;
}
@Override
public Object run() throws ZuulException {
System.out.println("Using Route filer");
return null;
}
}
| [
"YantriksIndia@123"
] | YantriksIndia@123 |
5110595b960ddc347d48010abf8398f6e7a5090c | 9f2fca0e70c93821395d73e3466003a4a668230d | /src/main/java/com/tour/test/executor/exception/ResponseException.java | dfcf7c865d5d4ff66adf05bdf19fac35a2f80446 | [] | no_license | bala4cs/mercurynewtour | 8b93e00257b670078aa87f1c5f876dcff7e99e1a | f17cee610756b10795cee9b2ea5fed6f4035f8f5 | refs/heads/master | 2022-07-15T11:47:51.917250 | 2019-12-12T05:27:05 | 2019-12-12T05:27:05 | 227,361,966 | 0 | 0 | null | 2022-06-29T17:50:29 | 2019-12-11T12:34:10 | Java | UTF-8 | Java | false | false | 996 | java | package com.tour.test.executor.exception;
import com.tour.logger.CustomLogger;
public class ResponseException extends Exception{
private static final CustomLogger LOGGER = new CustomLogger(ResponseException.class);
private static final long serialVersionUID = 1;
private String message = null;
public ResponseException() {
super();
}
public ResponseException(String message) {
super(message);
LOGGER.error(message);
}
public ResponseException(Throwable cause) {
super(cause);
}
public ResponseException(String result, Exception e) {
if(e.getMessage().contains("Content is not allowed in prolog.")){
LOGGER.error(" Please check the response : " +result);
}else{
LOGGER.error(e.getMessage());
}
}
@Override
public String toString() {
return message;
}
@Override
public String getMessage() {
return message;
}
}
| [
"you@example.com"
] | you@example.com |
de686e105b1ff4325841c215aefadb056a2e2011 | fe9c11ff67de1e3a542ca3a25199b55b194b6034 | /src/com/shihp/mybatis/test/MybatisTesst.java | 5e2b6b148351079c52227518ee6e0e94fd11720a | [
"Apache-2.0"
] | permissive | shihp/myMyBatis | e7883cc74674dbb53b2e515a6b8afe818a9ae8a4 | 86d4566e32215adf94f38a818d0079fbc0a19061 | refs/heads/main | 2023-01-23T02:08:37.566593 | 2020-12-08T08:01:01 | 2020-12-08T08:01:01 | 319,564,385 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 510 | java | package com.shihp.mybatis.test;
import com.shihp.mybatis.entity.User;
import com.shihp.mybatis.mapper.UserMapper;
import com.shihp.mybatis.session.SqlSession;
/**
* @author shihuipeng
* @date 2020/12/8
*/
public class MybatisTesst {
public static void main(String[] args) {
SqlSession sqlSession = new SqlSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = userMapper.selectUserById(1);
System.out.println("user = " + user);
}
}
| [
"778184959@qq.com"
] | 778184959@qq.com |
1a1a28336a5ba26cf320c77c292c35cc0b1c4fb3 | 246da5e21536012839fe6fdc8b2a992e9ebc385a | /src/avaliacao/exercicio15/OrdenandoArray.java | 03b8a0440a2d749ce6b42b55330e4cfce4410fa2 | [] | no_license | merilyncris/AulasJavaCampinasTech | ba1ae474f876f2454767335016efc499533b8d81 | b8cc7f2531c2ee0ca2c5b391484b5e08ca7a1bd3 | refs/heads/main | 2023-02-23T11:45:05.450114 | 2021-01-31T23:46:47 | 2021-01-31T23:46:47 | 330,404,923 | 0 | 0 | null | null | null | null | ISO-8859-1 | Java | false | false | 1,625 | java | package avaliacao.exercicio15;
import java.util.ArrayList;
import java.util.Scanner;
/*
* Escreva um programa que dada uma entrada de nรบmeros separados por ";", por exemplo: (72;56;4;108;12;57),
* escreva para o usuรกrio os nรบmero de forma ordenada.
* String entrada = "72;56;4;108;12;57";
* Lembre-se que essa string serรก dada pelo o usuรกrio. Utilize o Scanner;
* Converter essa string para um array de inteiros;
* Criar um mรฉtodo que ordena um array de inteiros;
* Devolver esse array de inteiros para o usuรกrio dessa forma:
* 4;12;56;57;72;108
*/
public class OrdenandoArray {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Digite uma sequencia de numeros separados por vรญrgulas (ex: 3;5;6;7):");
String numeros = scan.nextLine();
ArrayList<Integer> numerosSeparados = new ArrayList<>();
String[] numerosSeparados1 = numeros.split(";");
for (String cada : numerosSeparados1) {
int numero = Integer.valueOf(cada);
numerosSeparados.add(numero);
}
for (int i = 0; i < numerosSeparados.size(); i++) {
for (int j = numerosSeparados.size() - 1; j > i; j--) {
if (numerosSeparados.get(i) > numerosSeparados.get(j)) {
int tmp = numerosSeparados.get(i);
numerosSeparados.set(i, numerosSeparados.get(j));
numerosSeparados.set(j, tmp);
}
}
}
ArrayList<String> numb = new ArrayList<>();
for (int num : numerosSeparados) {
String numeroString = String.valueOf(num);
numb.add(numeroString);
}
String result = String.join(";", numb);
System.out.println(result);
scan.close();
}
}
| [
"merilyncris@gmail.com"
] | merilyncris@gmail.com |
da697a4c36ad896b4c7e6b8f194be395e394ec2d | 3920d17adf2315b60bd106818f437a96ac902a08 | /src/bhavana_assignment_21/StringOperationsWithoutClassCharacter.java | 9c12cd545e93b09dc95aba6c0b3bc7a37b915949 | [] | no_license | gaurav-4uk/JAVATechnoMar2021 | 882f4925f2a27f11698ef8a5a8c7b9b5e01a792b | 6bb08f38a6212bed883a746be8290c171b40e717 | refs/heads/main | 2023-05-16T22:32:43.176457 | 2021-06-05T17:16:49 | 2021-06-05T17:16:49 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,043 | java | package bhavana_assignment_21;
/*Count Digits,Letters, UpperCase characters, LowerCase characters, Special characters from predefined string.
Input: 1rRpd3F9#K(E
Output :
Total digit: 3
Total Letters: 7
Total Uppercase: 4
Total Lowercase: 3
Total Special char: 2 */
public class StringOperationsWithoutClassCharacter {
int letterCount,digitCount,upperCount,lowerCount,specialCount;
String input="1rRpd3F9#K(E";
void stringOperations() {
for(int index=0;index<input.length();index++) {
char ch=input.charAt(index);
if(ch>=65 && ch<=90)
upperCount++;
else if(ch>=97 && ch<=122)
lowerCount++;
else if(ch>=48 && ch<=57)
digitCount++;
else
specialCount++;
}
System.out.println("Letter count:"+(upperCount+lowerCount)+"\nDigit Count:"+digitCount+"\nSpecial char count:"+specialCount+"\nUpper count:"+upperCount+"\nLower Count"+lowerCount);
}
public static void main(String[] args) {
StringOperationsWithoutClassCharacter sc=new StringOperationsWithoutClassCharacter();
sc.stringOperations();
}
}
| [
"mahajanbhavana1489@gmail.com"
] | mahajanbhavana1489@gmail.com |
199bc6ff60aaefc88276a6cd25b107b353d53600 | 9fd161d3526a230cf8aca3e20095b4881106ebc0 | /mybatisgenerator/src/main/java/com/sz/dao/InnodbSysIndexesMapper.java | 4804439b5da3d2ac9c8aea99d0f1de8e8ac80276 | [] | no_license | 809477146/springbootstudy | c513bbcb403678199a0387f93524466d1bbf7b10 | 8ef17e0768ba24bb7296a3778601ab4feee0a4f3 | refs/heads/master | 2023-02-11T05:04:43.200805 | 2021-01-07T08:28:21 | 2021-01-07T08:28:21 | 327,229,799 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 195 | java | package com.sz.dao;
import com.sz.model.InnodbSysIndexes;
public interface InnodbSysIndexesMapper {
int insert(InnodbSysIndexes record);
int insertSelective(InnodbSysIndexes record);
} | [
"809477146@qq.com"
] | 809477146@qq.com |
b5d9c8dbfe109426c892cbbf468d029a3ad10c24 | 275ad7fe62569b3ef6a3274dcb1913699b510a0d | /hybrid_app/gen/com/example/hybrid_app/BuildConfig.java | 19e74df0c31d5f43dde6dd366863d69ee8182e77 | [] | no_license | BJTAWJ/jquery-moblie-phonegap | 1d915a70ac21747ae6cdea2b708be7870e6e456b | 5f14a1cde9bc8a8eadb5be3cfb20c77d9d0b6adc | refs/heads/master | 2016-09-01T09:01:25.581505 | 2013-05-25T08:31:00 | 2013-05-25T08:31:00 | 46,764,185 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 164 | java | /** Automatically generated file. DO NOT MODIFY */
package com.example.hybrid_app;
public final class BuildConfig {
public final static boolean DEBUG = true;
} | [
"skdocx@79d9a989-512a-7c44-cc52-7aa8cd925d5c"
] | skdocx@79d9a989-512a-7c44-cc52-7aa8cd925d5c |
9d1c3e7dde0783c1d58961eac62c65fd6af65731 | b060b42ed1e03c7b40a682db70bf8ba71943e3a3 | /src/main/java/com/app/init/AppInit.java | c63184c82cb1c2ec3da4692f7850d9c12edea70b | [] | no_license | satishyr/ControllerToUi | 6e12cf9581f17f337c4779687376e7bd5466b77e | ab7f891813f340263a78fe1f1b347134c03060ae | refs/heads/master | 2022-12-22T17:02:00.592833 | 2020-01-09T10:52:36 | 2020-01-09T10:52:36 | 232,778,155 | 0 | 0 | null | 2022-12-15T23:50:44 | 2020-01-09T10:01:12 | Java | UTF-8 | Java | false | false | 660 | java | package com.app.init;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import com.app.config.AppConfig;
public class AppInit extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
// TODO Auto-generated method stub
return new Class[] {AppConfig.class};
}
@Override
protected Class<?>[] getServletConfigClasses() {
// TODO Auto-generated method stub
return null;
}
@Override
protected String[] getServletMappings() {
// TODO Auto-generated method stub
return new String[] {"/mvc/*"};
}
}
| [
"y.satishkumar34@gmail.com"
] | y.satishkumar34@gmail.com |
3f40d3db0a9882eb672a629c6d7c6ff510dccdf7 | 6a99c5bc884e40e549680e01c35d4f6ebd34f24a | /OperadorUnario/src/cursojava/guil/OperadorUnariio.java | 3781f6f2518aa12039241ea32dd652824b878bd7 | [
"MIT"
] | permissive | Guilbertoliveira/CursoJava | 85ac67362e01f8d2d46b6e85a38fb53b46c1217c | 5e52ef822dd7f11e2193018468f7ef0dde95f429 | refs/heads/master | 2021-01-15T00:32:25.983193 | 2020-03-06T18:30:51 | 2020-03-06T18:30:51 | 242,813,672 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,155 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package cursojava.guil;
/**
*
* @author guilb
*/
public class OperadorUnariio extends javax.swing.JFrame {
/**
* Creates new form OperadorUnariio
*/
public OperadorUnariio() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
txtValor = new javax.swing.JTextField();
btnClick = new javax.swing.JButton();
lblResul = new javax.swing.JLabel();
jButton1 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
txtValor.setText("Digite o valor");
btnClick.setText("+");
btnClick.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
btnClickActionPerformed(evt);
}
});
lblResul.setText("Resultado +2");
jButton1.setText("-");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(150, 150, 150)
.addComponent(txtValor, javax.swing.GroupLayout.PREFERRED_SIZE, 82, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(btnClick)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jButton1, javax.swing.GroupLayout.PREFERRED_SIZE, 54, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(49, Short.MAX_VALUE))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(lblResul)
.addGap(142, 142, 142))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(43, 43, 43)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(txtValor, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(btnClick)
.addComponent(jButton1))
.addGap(18, 18, 18)
.addComponent(lblResul)
.addContainerGap(202, Short.MAX_VALUE))
);
pack();
}// </editor-fold>//GEN-END:initComponents
private void btnClickActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnClickActionPerformed
int i = Integer.parseInt(txtValor.getText());
i += 2;
lblResul.setText(Integer.toString(i));
}//GEN-LAST:event_btnClickActionPerformed
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
int i = Integer.parseInt(txtValor.getText());
i -= 2;
lblResul.setText(Integer.toString(i));
}//GEN-LAST:event_jButton1ActionPerformed
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(OperadorUnariio.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(OperadorUnariio.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(OperadorUnariio.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(OperadorUnariio.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new OperadorUnariio().setVisible(true);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton btnClick;
private javax.swing.JButton jButton1;
private javax.swing.JLabel lblResul;
private javax.swing.JTextField txtValor;
// End of variables declaration//GEN-END:variables
}
| [
"41201436+Guilbertoliveira@users.noreply.github.com"
] | 41201436+Guilbertoliveira@users.noreply.github.com |
f440c44a101cbbe42fe90cafe5f94266407ca167 | 6d0ffbee5011340945867e3ac007e5046b86110b | /JavaSpring-lesson_40/inventory-management/src/main/java/inventory/service/ProductService.java | d44a6f75e072a78f6aaaea3f676b1dc100ff53b6 | [
"Apache-2.0"
] | permissive | Trongphamsr/githug-springboot | 5eca4837d75787849e4f655de5ea8d8726e67097 | 48bbb922116193ccd55688e1b7c0bbca8c4db86a | refs/heads/master | 2020-05-24T16:14:44.579438 | 2019-05-18T11:53:27 | 2019-05-18T11:53:27 | 187,350,439 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,864 | java | package inventory.service;
import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import inventory.dao.CategoryDAO;
import inventory.dao.ProductInfoDAO;
import inventory.model.Category;
import inventory.model.Paging;
import inventory.model.ProductInfo;
import inventory.util.ConfigLoader;
@Service
public class ProductService {
@Autowired
private CategoryDAO<Category> categoryDAO;
@Autowired
private ProductInfoDAO<ProductInfo> productInfoDAO;
private static final Logger log = Logger.getLogger(ProductService.class);
public void saveCategory(Category category) throws Exception{
log.info("Insert category "+category.toString());
category.setActiveFlag(1);
category.setCreateDate(new Date());
category.setUpdateDate(new Date());
categoryDAO.save(category);
}
public void updateCategory(Category category) throws Exception {
log.info("Update category "+category.toString());
category.setUpdateDate(new Date());
categoryDAO.update(category);
}
public void deleteCategory(Category category) throws Exception{
category.setActiveFlag(0);
category.setUpdateDate(new Date());
log.info("Delete category "+category.toString());
categoryDAO.update(category);
}
public List<Category> findCategory(String property , Object value){
log.info("=====Find by property category start====");
log.info("property ="+property +" value"+ value.toString());
return categoryDAO.findByProperty(property, value);
}
public List<Category> getAllCategory(Category category,Paging paging){
log.info("show all category");
StringBuilder queryStr = new StringBuilder();
Map<String, Object> mapParams = new HashMap<>();
if(category!=null) {
if(category.getId()!=null && category.getId()!=0) {
queryStr.append(" and model.id=:id");
mapParams.put("id", category.getId());
}
if(category.getCode()!=null && !StringUtils.isEmpty(category.getCode())) {
queryStr.append(" and model.code=:code");
mapParams.put("code", category.getCode());
}
if(category.getName()!=null && !StringUtils.isEmpty(category.getName()) ) {
queryStr.append(" and model.name like :name");
mapParams.put("name", "%"+category.getName()+"%");
}
}
return categoryDAO.findAll(queryStr.toString(), mapParams,paging);
}
public Category findByIdCategory(int id) {
log.info("find category by id ="+id);
return categoryDAO.findById(Category.class, id);
}
// PRODUCT INFO
public void saveProductInfo(ProductInfo productInfo) throws Exception{
log.info("Insert productInfo "+productInfo.toString());
productInfo.setActiveFlag(1);
productInfo.setCreateDate(new Date());
productInfo.setUpdateDate(new Date());
String fileName = System.currentTimeMillis()+"_"+productInfo.getMultipartFile().getOriginalFilename();
processUploadFile(productInfo.getMultipartFile(),fileName);
productInfo.setImgUrl("/upload/"+fileName);
productInfoDAO.save(productInfo);
}
public void updateProductInfo(ProductInfo productInfo) throws Exception {
log.info("Update productInfo "+productInfo.toString());
if(!productInfo.getMultipartFile().getOriginalFilename().isEmpty()) {
String fileName = System.currentTimeMillis()+"_"+productInfo.getMultipartFile().getOriginalFilename();
processUploadFile(productInfo.getMultipartFile(),fileName);
productInfo.setImgUrl("/upload/"+fileName);
}
productInfo.setUpdateDate(new Date());
productInfoDAO.update(productInfo);
}
public void deleteProductInfo(ProductInfo productInfo) throws Exception{
productInfo.setActiveFlag(0);
productInfo.setUpdateDate(new Date());
log.info("Delete productInfo "+productInfo.toString());
productInfoDAO.update(productInfo);
}
public List<ProductInfo> findProductInfo(String property , Object value){
log.info("=====Find by property productInfo start====");
log.info("property ="+property +" value"+ value.toString());
return productInfoDAO.findByProperty(property, value);
}
public List<ProductInfo> getAllProductInfo(ProductInfo productInfo,Paging paging){
log.info("show all productInfo");
StringBuilder queryStr = new StringBuilder();
Map<String, Object> mapParams = new HashMap<>();
if(productInfo!=null) {
if(productInfo.getId()!=null && productInfo.getId()!=0) {
queryStr.append(" and model.id=:id");
mapParams.put("id", productInfo.getId());
}
if(productInfo.getCode()!=null && !StringUtils.isEmpty(productInfo.getCode())) {
queryStr.append(" and model.code=:code");
mapParams.put("code", productInfo.getCode());
}
if(productInfo.getName()!=null && !StringUtils.isEmpty(productInfo.getName()) ) {
queryStr.append(" and model.name like :name");
mapParams.put("name", "%"+productInfo.getName()+"%");
}
}
return productInfoDAO.findAll(queryStr.toString(), mapParams,paging);
}
public ProductInfo findByIdProductInfo(int id) {
log.info("find productInfo by id ="+id);
return productInfoDAO.findById(ProductInfo.class, id);
}
private void processUploadFile(MultipartFile multipartFile,String fileName) throws IllegalStateException, IOException {
if(!multipartFile.getOriginalFilename().isEmpty()) {
File dir = new File(ConfigLoader.getInstance().getValue("upload.location"));
if(!dir.exists()) {
dir.mkdirs();
}
File file = new File(ConfigLoader.getInstance().getValue("upload.location"),fileName);
multipartFile.transferTo(file);
}
}
}
| [
"anhhop200193@gmail.com"
] | anhhop200193@gmail.com |
089c3fbfd8b2a8c959a37959b28479535451866e | 7691d61c8ade331e6a4a6a13e8a17c2dde0b6135 | /core/src/main/java/org/infinispan/reactive/publisher/impl/KeyPublisherResult.java | 3e5f99db5179f296554ab23e0775519e5610e557 | [
"Apache-2.0",
"LicenseRef-scancode-dco-1.1"
] | permissive | joaedwar/infinispan | 84a4aa33b9199536a5f03a467c962cdfb012fead | 2380c91c4ece8c4efed18e943ed3f33b2570d993 | refs/heads/master | 2020-08-05T03:02:41.833286 | 2019-10-04T00:21:35 | 2019-10-04T00:21:35 | 205,343,641 | 0 | 0 | Apache-2.0 | 2019-08-30T08:52:42 | 2019-08-30T08:52:41 | null | UTF-8 | Java | false | false | 1,036 | java | package org.infinispan.reactive.publisher.impl;
import java.util.Set;
import org.infinispan.commons.util.IntSet;
/**
* A PublisherResult that was performed due to included keys. Note that this response is only ever created on the
* originator node. This is because we can't have a partial response with key based publishers. Either all results
* are returned or the node crashes or has an exception.
* @author wburns
* @since 10.0
*/
public class KeyPublisherResult<K, R> implements PublisherResult<R> {
private final Set<K> suspectedKeys;
public KeyPublisherResult(Set<K> suspectedKeys) {
this.suspectedKeys = suspectedKeys;
}
@Override
public IntSet getSuspectedSegments() {
return null;
}
@Override
public Set<K> getSuspectedKeys() {
return suspectedKeys;
}
@Override
public R getResult() {
return null;
}
@Override
public String toString() {
return "KeyPublisherResult{" +
", suspectedKeys=" + suspectedKeys +
'}';
}
}
| [
"remerson@redhat.com"
] | remerson@redhat.com |
53372bae7fc20f094c17b2cee126a8ad6ad3f4ca | 50520094f8c60f991d4bdeee4ad55bb18fc5ab13 | /yxl/src/com/ptl/yxl/service/ModuleService.java | 94c069d6db1d0f0b4634777fb70ebbb483a675eb | [] | no_license | johnbukaixin/my | ed1c6102553f01d8412e7e3b7b4fba9ce2252353 | 583e81f3d48be52d3ee181fc8a7433a67e8a16a5 | refs/heads/master | 2021-01-01T04:25:47.043172 | 2016-11-06T11:40:08 | 2016-11-06T11:40:08 | 56,139,219 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 154 | java | package com.ptl.yxl.service;
import java.util.List;
import com.ptl.yxl.pojo.Module;
public interface ModuleService {
List<Module> getAllModules();
}
| [
"1151367905@qq.com"
] | 1151367905@qq.com |
017d4ed147383b5e15313e074e7a111421920698 | 038ee6b20cae51169a2ed4ed64a7b8e99b5cbaad | /schemaOrgGson/src/org/kyojo/schemaorg/m3n5/gson/core/container/ExecutableLibraryNameDeserializer.java | de42e71ff26ae41e0e07d7b33db271b5e4e8a3e9 | [
"Apache-2.0"
] | permissive | nagaikenshin/schemaOrg | 3dec1626781913930da5585884e3484e0b525aea | 4c9d6d098a2741c2dc2a814f1c708ee55c36e9a8 | refs/heads/master | 2021-06-25T04:52:49.995840 | 2019-05-12T06:22:37 | 2019-05-12T06:22:37 | 134,319,974 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,140 | java | package org.kyojo.schemaorg.m3n5.gson.core.container;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
import org.kyojo.gson.JsonDeserializationContext;
import org.kyojo.gson.JsonDeserializer;
import org.kyojo.gson.JsonElement;
import org.kyojo.gson.JsonParseException;
import org.kyojo.schemaorg.m3n5.core.impl.EXECUTABLE_LIBRARY_NAME;
import org.kyojo.schemaorg.m3n5.core.Container.ExecutableLibraryName;
import org.kyojo.schemaorg.m3n5.gson.DeserializerTemplate;
public class ExecutableLibraryNameDeserializer implements JsonDeserializer<ExecutableLibraryName> {
public static Map<String, Field> fldMap = new HashMap<>();
@Override
public ExecutableLibraryName deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext context)
throws JsonParseException {
if(jsonElement.isJsonPrimitive()) {
return new EXECUTABLE_LIBRARY_NAME(jsonElement.getAsString());
}
return DeserializerTemplate.deserializeSub(jsonElement, type, context,
new EXECUTABLE_LIBRARY_NAME(), ExecutableLibraryName.class, EXECUTABLE_LIBRARY_NAME.class, fldMap);
}
}
| [
"nagai@nagaikenshin.com"
] | nagai@nagaikenshin.com |
fa178a9ba09d907e3a0a8f63b27dee297d6006ef | 13ea5da0b7b8d4ba87d622a5f733dcf6b4c5f1e3 | /crash-reproduction-ws/results/MATH-84b-1-20-Single_Objective_GGA-WeightedSum/org/apache/commons/math/optimization/direct/DirectSearchOptimizer_ESTest.java | 81e1cac75711b7422011aae50e01c23b907df06d | [
"MIT",
"CC-BY-4.0"
] | permissive | STAMP-project/Botsing-basic-block-coverage-application | 6c1095c6be945adc0be2b63bbec44f0014972793 | 80ea9e7a740bf4b1f9d2d06fe3dcc72323b848da | refs/heads/master | 2022-07-28T23:05:55.253779 | 2022-04-20T13:54:11 | 2022-04-20T13:54:11 | 285,771,370 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,412 | java | /*
* This file was automatically generated by EvoSuite
* Tue Mar 31 11:23:38 UTC 2020
*/
package org.apache.commons.math.optimization.direct;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.runtime.EvoAssertions.*;
import java.util.Comparator;
import org.apache.commons.math.optimization.OptimizationException;
import org.apache.commons.math.optimization.RealPointValuePair;
import org.apache.commons.math.optimization.direct.MultiDirectional;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.junit.runner.RunWith;
@RunWith(EvoRunner.class) @EvoRunnerParameters(useVFS = true, useJEE = true)
public class DirectSearchOptimizer_ESTest extends DirectSearchOptimizer_ESTest_scaffolding {
@Test(timeout = 4000)
public void test0() throws Throwable {
MultiDirectional multiDirectional0 = new MultiDirectional();
multiDirectional0.setMaxIterations((-14));
try {
multiDirectional0.iterateSimplex((Comparator<RealPointValuePair>) null);
fail("Expecting exception: OptimizationException");
} catch(OptimizationException e) {
//
// org.apache.commons.math.MaxIterationsExceededException: Maximal number of iterations (-14) exceeded
//
verifyException("org.apache.commons.math.optimization.direct.DirectSearchOptimizer", e);
}
}
}
| [
"pouria.derakhshanfar@gmail.com"
] | pouria.derakhshanfar@gmail.com |
6b538670fa1037b11e3b9109425fdf1f195aef60 | 6baf22fbb88f13b0f5527efd0b983a2b00fad824 | /src/AbstractDataTypes/Queue.java | f2c5d96dc301af03617fa7d0f0bdec209dbde9ee | [] | no_license | drahsansaleem/DataStructures-ADT | c3b19387f55f59f3d828f54f1675bd99db1d8878 | 029ce909f55c88646f650d4f09a379b87a320be0 | refs/heads/main | 2023-09-03T02:49:39.118817 | 2021-03-25T09:56:49 | 2021-03-25T09:56:49 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 125 | java | package AbstractDataTypes;
public interface Queue<T> {
boolean isFull();
void enQueue(T data);
T deQueue();
}
| [
"Osadkovski"
] | Osadkovski |
8ce2d720e8463a74efd60de49af2910c7aca243d | dcad64e482fd958663a4334f27b8d9ba998f3187 | /src/NowCoder/Main.java | 9b1af1e35195a87505f947cb150d1a81bfe31d41 | [] | no_license | SamanthaChen/LeetCode2 | 0f570b03fb232134633cd68d1cf3b49296ea5a0e | 027c8888b5c886d52bd3c64e50ae28508e21f42b | refs/heads/master | 2020-12-25T14:57:41.684693 | 2016-10-03T13:20:14 | 2016-10-03T13:20:14 | 66,910,480 | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 3,612 | java | package NowCoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//ๅๅปบๆฅๅ้ฎ็ๅฝๅ
ฅๅฏน่ฑก
Scanner cin = new Scanner(System.in);
// ๆฅๅๆไปถๅ็งฐๆ่
ๆไปถ่ทฏๅพ
String file = null;
// ่ทๅๆไปถ่ทฏๅพ ๆๅไธไธชโ\โ ไธๆ ็ดขๅผ
int lastIndex = 0;
// ่ทๅๆไปถๅ็งฐ
// ๆฅๅ้่ฏฏๅบ็ฐ็่กๅท
int errorLine = 0;
// ๅๅปบไธไธชHashMap<ErrLog>
HashMap<String, ErrLog> hashMap = new HashMap<String, ErrLog>();
ErrLog errLog = null;
String key = null;
StringBuilder sbBuilder = new StringBuilder();
while (cin.hasNext()) {
// ็ฌฌไธไธชๅๆฐไธบๆไปถๅ็งฐๆๆไปถ่ทฏๅพ
file = cin.next();
// ่ทๅ้่ฏฏ่กๅท
errorLine = cin.nextInt();
// ่ทๅๆๅไธไธช'\'็็ดขๅผ
lastIndex = file.lastIndexOf('\\');
// ๅฆๆๆฒกๆๆพๅฐ่ฏดๆไธๆฏ่ทฏๅพ,็ดๆฅ่ฟๅๆไปถๅ
// ๆฏ่ทฏๅพ ๅฐฑๆชๅ\ๅ้ข็ๅญ็ฌฆไธฒไฝไธบๆไปถๅ
sbBuilder
.append(lastIndex < 0 ? file : file.substring(lastIndex + 1))
.append(" ").append(errorLine);
key = sbBuilder.toString();
sbBuilder.setLength(0);
// ๅฐ้่ฏฏ่ฎฐๅฝๆทปๅ ่ฟhashMap ไธญ
errLog = hashMap.get(key);
if (errLog == null) {
// ๅฆๆไธๅญๅจ๏ผnew ไธไธชๅนถๆทปๅ ่ฟๅป
hashMap.put(key, new ErrLog(key, 1));
} else errLog.size++; //ๅญๅจ๏ผๅฐฑๅฐ้่ฏฏๆฌกๆฐ็ดฏๅ
}
cin.close();
// ----------ไปฅไธๅฐฑๆฏ็ป่ฎก้่ฏฏไฟกๆฏ๏ผไธ้ขๆฏๅๅผ------------------
ArrayList<ErrLog> list = new ArrayList<ErrLog>(hashMap.values());
// ๆ นๆฎ ้่ฏฏๆฌกๆฐๆฏ่พ๏ผๅฐ้่ฏฏๆฌกๆฐๅค็ๆพๅ้ข๏ผๅฆๆ้่ฏฏๆฌกๆฐไธ่ด๏ผๅฐๅบ็ฐ้กบๅบๆฉ็ๆพๅฐๅ้ข ่ฟ่กๆๅบ
Comparator<ErrLog> cmp = new Comparator<ErrLog>() {
@Override
public int compare(ErrLog o1, ErrLog o2) {
return o2.size - o1.size == 0 ? (o1.queueMark - o2.queueMark)
: o2.size - o1.size;
}
};
Collections.sort(list, cmp);
// ๅๅบๅ8ไธช๏ผๅนถ่พๅบ
int lens = 8 > list.size() ? list.size() : 8;
for (int i = 0; i < lens; i++) {
//่ฟ้ๆไปถๅๅฆๆๅคงไบ16ไฝ ่ฟ้่ฆๆชๅๆไปถๅ16ไฝ + ่กๅท ่พๅบ
errLog = list.get(i);
//่ฟๆ ทๅฐฑ่ทๅๅฐไบๅ็็ฌฆ' '็็ดขๅผไบ,็ถๅๅพๅๆจ16ไฝๅฐฑๆฏๆไปฌ่ฆ่พๅบ็ๆไปถๅไบ
lastIndex = errLog.name.lastIndexOf(" ");
lastIndex = lastIndex - 16 < 0 ? 0 : lastIndex - 16;
// ่ทๅๆไปถๅๅนถ่พๅบ
System.out.println((lastIndex == 0 ? errLog.name : errLog.name
.substring(lastIndex)) + " " + errLog.size);
}
}
}
class ErrLog {
// ๆญค็ฑปๅนถไธๆ ๅ๏ผไป
ๆนไพฟๆญค้ข็ฎๅฎ็ฐ่ๅทฒ
static int mark; //่พ
ๅฉๅฎ็ฐๅญๆฎตqueueMarkๆๅบ็ฐ้กบๅบ่ชๅข
String name;//fileName ๅญๅจ้่ฏฏ็ๆไปถๅ็งฐ๏ผ็ฑๅฎๆด็ๆไปถๅ๏ผไธ้่ฏฏ่กๅท็ปๆใ
int queueMark; // ๆ ่ฎฐๅบ็ฐ็้กบๅบ
int size; // ็ป่ฎกๅบ็ฐ้่ฏฏ็ๆฌกๆฐ
public ErrLog(String name, int size){
super();
this.name = name;
this.queueMark = mark++;
this.size = size;
}
}
| [
"chenximan@gmail.com"
] | chenximan@gmail.com |
44a96b63906994c9ed0e343ea6a4cbaa30f46e83 | c885ef92397be9d54b87741f01557f61d3f794f3 | /results/Math-5/org.apache.commons.math3.complex.Complex/BBC-F0-opt-60/tests/8/org/apache/commons/math3/complex/Complex_ESTest.java | df77054a6269881d3f0d2ac0dc2e1f08c9c79ce0 | [
"CC-BY-4.0",
"MIT"
] | permissive | pderakhshanfar/EMSE-BBC-experiment | f60ac5f7664dd9a85f755a00a57ec12c7551e8c6 | fea1a92c2e7ba7080b8529e2052259c9b697bbda | refs/heads/main | 2022-11-25T00:39:58.983828 | 2022-04-12T16:04:26 | 2022-04-12T16:04:26 | 309,335,889 | 0 | 1 | null | 2021-11-05T11:18:43 | 2020-11-02T10:30:38 | null | UTF-8 | Java | false | false | 4,208,811 | java | /*
* This file was automatically generated by EvoSuite
* Tue Oct 19 17:15:13 GMT 2021
*/
package org.apache.commons.math3.complex;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.runtime.EvoAssertions.*;
import java.util.List;
import org.apache.commons.math3.complex.Complex;
import org.apache.commons.math3.complex.ComplexField;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.junit.runner.RunWith;
@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true)
public class Complex_ESTest extends Complex_ESTest_scaffolding {
@Test(timeout = 4000)
public void test000() throws Throwable {
Complex complex0 = Complex.ONE;
Complex complex1 = Complex.valueOf(1006.158308, (-4.0873400635183405E225));
Complex complex2 = complex0.I.pow(complex1);
complex2.nthRoot(822);
complex2.ONE.toString();
complex0.readResolve();
Complex complex3 = Complex.ONE;
Complex complex4 = complex0.subtract(complex3);
Complex complex5 = complex1.divide((-56.2442));
Complex complex6 = complex4.INF.log();
complex6.add(complex5);
Complex complex7 = complex5.sqrt1z();
complex0.getField();
Complex complex8 = complex3.add((-56.2442));
complex1.toString();
complex4.abs();
complex0.ZERO.createComplex(1700.77666, 6.283185307179586);
Complex complex9 = complex2.sqrt1z();
complex3.nthRoot(3380);
complex2.sqrt1z();
Complex complex10 = complex9.asin();
complex8.subtract(6.283185307179586);
complex6.pow(complex7);
complex4.conjugate();
complex7.divide(complex10);
}
@Test(timeout = 4000)
public void test001() throws Throwable {
Complex complex0 = Complex.valueOf(15.619134970557413, 20.0);
complex0.tan();
}
@Test(timeout = 4000)
public void test002() throws Throwable {
Complex complex0 = Complex.valueOf(Double.POSITIVE_INFINITY, 1.0000000287704558);
complex0.ZERO.nthRoot(1);
complex0.NaN.tan();
complex0.sqrt();
Complex complex1 = complex0.conjugate();
complex1.atan();
}
@Test(timeout = 4000)
public void test003() throws Throwable {
Complex complex0 = Complex.I;
complex0.nthRoot(1);
Complex complex1 = complex0.divide((double) 1);
complex1.conjugate();
Complex complex2 = complex1.negate();
complex2.atan();
}
@Test(timeout = 4000)
public void test004() throws Throwable {
Complex complex0 = new Complex((-20.0), Double.POSITIVE_INFINITY);
Complex complex1 = new Complex((-20.0));
complex1.getField();
Complex complex2 = complex0.multiply((-2538.0840208488));
Complex complex3 = Complex.ONE;
Complex complex4 = complex3.exp();
Complex complex5 = complex1.subtract(complex2);
complex0.abs();
complex5.tan();
complex4.cosh();
complex1.createComplex(459.6279, (-1405.321655904));
complex4.toString();
complex1.asin();
complex0.subtract((-1.0));
}
@Test(timeout = 4000)
public void test005() throws Throwable {
Complex complex0 = Complex.I;
int int0 = 3533;
try {
complex0.add((Complex) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// null is not allowed
//
verifyException("org.apache.commons.math3.util.MathUtils", e);
}
}
@Test(timeout = 4000)
public void test006() throws Throwable {
Complex complex0 = Complex.valueOf((-20.0), Double.POSITIVE_INFINITY);
Complex complex1 = complex0.ONE.subtract((-20.0));
complex0.NaN.pow((-877.2474264));
complex0.nthRoot(1);
complex1.multiply(complex0);
}
@Test(timeout = 4000)
public void test007() throws Throwable {
Complex complex0 = Complex.I;
complex0.subtract(Double.NaN);
}
@Test(timeout = 4000)
public void test008() throws Throwable {
Complex complex0 = new Complex((-2445.9167200530023), (-2445.9167200530023));
Complex complex1 = complex0.tan();
complex1.sqrt();
complex0.pow((-2445.9167200530023));
}
@Test(timeout = 4000)
public void test009() throws Throwable {
Complex complex0 = Complex.valueOf((-3283.3286189));
Complex complex1 = Complex.ONE;
Complex complex2 = complex1.ONE.tan();
complex1.getField();
Complex complex3 = complex0.pow(complex1);
Complex complex4 = complex0.createComplex(1722.2444566, (-2.6033824355191673E-8));
complex4.exp();
complex3.sinh();
complex4.I.toString();
Complex complex5 = complex3.pow((-3283.3286189));
Complex complex6 = complex5.add(complex1);
complex6.ZERO.createComplex(1.0221116781394812E-4, (-2.6033824355191673E-8));
Complex complex7 = complex0.multiply(213);
complex7.ONE.add((-1252.399264973388));
complex3.sin();
complex7.sqrt1z();
complex1.readResolve();
complex2.conjugate();
}
@Test(timeout = 4000)
public void test010() throws Throwable {
Complex complex0 = new Complex(6.1382342622, (-537514.9473575001));
Complex complex1 = complex0.tan();
complex1.ZERO.pow(complex0);
Complex complex2 = complex0.sin();
complex2.divide(52.06895541113);
}
@Test(timeout = 4000)
public void test011() throws Throwable {
Complex complex0 = Complex.valueOf((-107.13), 3.491470347090126E290);
Complex complex1 = complex0.asin();
complex1.readResolve();
}
@Test(timeout = 4000)
public void test012() throws Throwable {
Complex complex0 = Complex.INF;
Complex complex1 = Complex.I;
complex0.pow(complex1);
complex0.divide(Double.POSITIVE_INFINITY);
Complex complex2 = Complex.I;
}
@Test(timeout = 4000)
public void test013() throws Throwable {
Complex complex0 = Complex.I;
Complex complex1 = Complex.NaN;
complex0.ZERO.pow(complex1);
complex0.divide(Double.POSITIVE_INFINITY);
Complex complex2 = Complex.I;
}
@Test(timeout = 4000)
public void test014() throws Throwable {
Complex complex0 = Complex.I;
Complex complex1 = complex0.tanh();
Complex complex2 = Complex.ZERO;
complex0.equals(complex2);
complex1.tan();
}
@Test(timeout = 4000)
public void test015() throws Throwable {
Complex complex0 = Complex.valueOf((-2438.256513));
Complex complex1 = complex0.acos();
Complex complex2 = new Complex((-2438.256513));
Complex complex3 = complex0.multiply((-2438.256513));
Complex complex4 = complex1.NaN.pow(complex0);
Complex complex5 = complex4.NaN.negate();
Complex complex6 = complex1.sqrt1z();
Complex complex7 = complex6.I.atan();
complex0.getReal();
complex4.multiply(363);
complex5.sqrt();
Complex complex8 = new Complex(363);
Complex complex9 = complex2.multiply(2.892405905186024E-4);
Complex complex10 = complex3.cos();
complex4.hashCode();
complex7.abs();
Complex complex11 = complex6.tanh();
complex10.conjugate();
Complex complex12 = Complex.NaN;
complex9.getReal();
complex11.multiply(complex1);
Complex complex13 = Complex.I;
complex11.subtract(complex9);
complex9.divide(complex5);
Complex complex14 = complex2.cosh();
Complex complex15 = Complex.I;
complex13.readResolve();
complex10.asin();
complex10.acos();
complex6.hashCode();
Complex complex16 = Complex.NaN;
complex4.sqrt1z();
complex14.cosh();
Complex complex17 = complex2.exp();
complex12.asin();
complex17.add(1935.425193885);
}
@Test(timeout = 4000)
public void test016() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, Double.POSITIVE_INFINITY);
complex0.INF.readResolve();
Complex complex1 = complex0.tan();
complex1.ONE.nthRoot(1405);
Complex complex2 = complex1.multiply((-187));
complex0.createComplex(297.428864, (-1740.317));
try {
complex2.subtract((Complex) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// null is not allowed
//
verifyException("org.apache.commons.math3.util.MathUtils", e);
}
}
@Test(timeout = 4000)
public void test017() throws Throwable {
Complex complex0 = Complex.valueOf(1.0);
complex0.getReal();
Complex complex1 = Complex.ZERO;
Complex complex2 = complex1.multiply(157);
Complex complex3 = complex1.sqrt();
Complex complex4 = new Complex(2177.51256665);
Complex complex5 = complex0.multiply(Double.NaN);
Complex complex6 = complex3.cos();
complex2.abs();
complex0.hashCode();
complex5.abs();
Complex complex7 = new Complex((-1041.3838426), 3864.7);
complex7.tanh();
Complex complex8 = complex4.conjugate();
Complex complex9 = Complex.NaN;
complex7.getReal();
complex5.multiply(complex0);
Complex complex10 = Complex.I;
complex2.subtract(complex7);
complex3.divide(complex1);
Complex complex11 = complex7.cosh();
complex11.I.tanh();
Complex complex12 = Complex.I;
complex1.readResolve();
Complex complex13 = complex8.asin();
Complex complex14 = complex6.acos();
complex13.hashCode();
Complex complex15 = Complex.NaN;
complex10.sqrt1z();
complex14.cosh();
complex4.exp();
complex2.asin();
complex12.getField();
}
@Test(timeout = 4000)
public void test018() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, Double.POSITIVE_INFINITY);
complex0.getField();
complex0.toString();
Complex complex1 = Complex.INF;
complex0.multiply(complex1);
}
@Test(timeout = 4000)
public void test019() throws Throwable {
Complex complex0 = Complex.valueOf(1727.575, (-20.0));
Complex complex1 = (Complex)complex0.readResolve();
Complex complex2 = complex0.sinh();
complex1.getField();
Complex complex3 = Complex.valueOf(1727.575);
complex3.toString();
complex3.multiply(complex2);
complex0.tan();
}
@Test(timeout = 4000)
public void test020() throws Throwable {
Complex complex0 = Complex.valueOf((-2438.256513));
Complex complex1 = complex0.acos();
Complex complex2 = complex1.tanh();
Complex complex3 = complex0.multiply((-2438.256513));
Complex complex4 = complex1.NaN.pow(complex0);
Complex complex5 = complex4.NaN.negate();
Complex complex6 = complex1.sqrt1z();
Complex complex7 = complex6.I.atan();
complex0.getReal();
Complex complex8 = complex4.multiply(363);
Complex complex9 = complex5.sqrt();
complex9.readResolve();
complex2.multiply(2.892405905186024E-4);
Complex complex10 = complex3.cos();
complex4.hashCode();
complex7.abs();
Complex complex11 = complex6.tanh();
complex10.conjugate();
Complex complex12 = Complex.ZERO;
complex12.getReal();
complex8.multiply(complex5);
complex5.subtract(complex12);
complex11.divide(complex2);
Complex complex13 = complex3.cosh();
Complex complex14 = new Complex(363, Double.NaN);
complex14.readResolve();
Complex complex15 = complex14.asin();
complex6.acos();
complex4.hashCode();
Complex complex16 = Complex.NaN;
complex16.sqrt1z();
complex7.cosh();
complex15.exp();
complex0.asin();
complex9.tanh();
complex13.log();
}
@Test(timeout = 4000)
public void test021() throws Throwable {
Complex complex0 = Complex.ZERO;
Complex complex1 = complex0.ZERO.exp();
Complex complex2 = complex1.ONE.multiply(2.9850404523368767E-171);
Complex complex3 = complex0.NaN.createComplex((-2335.91542), 2.9850404523368767E-171);
complex3.I.sqrt();
Complex complex4 = Complex.ONE;
Complex complex5 = new Complex(2.9850404523368767E-171, 2.9850404523368767E-171);
complex2.sqrt1z();
Object object0 = complex5.readResolve();
complex2.equals(object0);
Complex complex6 = complex5.cosh();
Complex complex7 = complex4.reciprocal();
complex7.ONE.cosh();
complex6.readResolve();
complex5.reciprocal();
complex7.toString();
complex2.add(complex7);
complex3.readResolve();
complex0.sqrt();
}
@Test(timeout = 4000)
public void test022() throws Throwable {
Complex complex0 = Complex.valueOf(20.0);
Complex complex1 = complex0.tanh();
complex0.I.acos();
Complex complex2 = complex1.tanh();
complex0.cos();
complex0.tan();
complex0.divide(complex2);
}
@Test(timeout = 4000)
public void test023() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, Double.POSITIVE_INFINITY);
Complex complex1 = Complex.I;
Complex complex2 = complex1.subtract(complex0);
complex1.divide(complex2);
complex0.cosh();
Complex complex3 = new Complex(0.0, 0.0);
Complex complex4 = Complex.valueOf(Double.POSITIVE_INFINITY);
complex4.INF.sinh();
complex1.createComplex(743.323, 6.283185307179586);
complex1.sqrt();
}
@Test(timeout = 4000)
public void test024() throws Throwable {
Complex complex0 = Complex.ZERO;
Complex complex1 = complex0.ZERO.exp();
Complex complex2 = complex1.ONE.multiply(2.9850404523368767E-171);
Complex complex3 = complex0.NaN.createComplex((-2335.91542), 2.9850404523368767E-171);
Complex complex4 = Complex.ONE;
Complex complex5 = new Complex(2.9850404523368767E-171, 2.9850404523368767E-171);
Complex complex6 = complex2.sqrt1z();
Complex complex7 = Complex.INF;
complex7.INF.add(Double.NaN);
Object object0 = complex5.readResolve();
complex6.isInfinite();
Complex complex8 = complex0.cosh();
Complex complex9 = complex8.I.reciprocal();
complex9.INF.cos();
((Complex) object0).ONE.readResolve();
complex2.reciprocal();
complex0.INF.toString();
complex0.add(complex3);
complex0.readResolve();
complex4.sqrt1z();
}
@Test(timeout = 4000)
public void test025() throws Throwable {
Complex complex0 = new Complex(Double.NaN);
complex0.abs();
complex0.getField();
Complex complex1 = Complex.ZERO;
Complex complex2 = complex0.divide(complex1);
Complex complex3 = complex2.log();
complex3.ONE.sqrt1z();
complex2.isInfinite();
complex0.getField();
complex3.log();
Complex complex4 = Complex.ONE;
Complex complex5 = complex0.tan();
complex5.exp();
}
@Test(timeout = 4000)
public void test026() throws Throwable {
Complex complex0 = Complex.valueOf(1.0);
Complex complex1 = complex0.I.divide(1.0);
Complex complex2 = complex0.negate();
Complex complex3 = complex0.sin();
Complex complex4 = complex3.subtract(Double.POSITIVE_INFINITY);
complex2.hashCode();
complex4.reciprocal();
complex1.readResolve();
Complex complex5 = new Complex(2.9850404523368767E-171, Double.POSITIVE_INFINITY);
complex5.equals(complex1);
complex4.getArgument();
Complex complex6 = Complex.ZERO;
complex6.readResolve();
}
@Test(timeout = 4000)
public void test027() throws Throwable {
Complex complex0 = new Complex((-1526.0643415));
complex0.NaN.cosh();
Complex complex1 = complex0.sqrt();
Complex complex2 = complex1.ONE.cosh();
Complex complex3 = complex1.INF.multiply(complex2);
complex3.INF.sqrt();
Complex complex4 = complex0.conjugate();
Complex complex5 = Complex.valueOf((-1526.0643415), (-859.5586949377));
Complex complex6 = complex1.subtract(complex5);
Complex complex7 = complex6.ZERO.multiply((-2762));
Complex complex8 = complex4.tanh();
complex1.add(complex6);
Complex complex9 = complex8.subtract(complex2);
complex2.I.divide(complex5);
complex9.INF.toString();
Complex complex10 = complex7.multiply(complex8);
complex6.getField();
Complex complex11 = complex9.multiply((double) (-2762));
complex11.pow(complex6);
Complex complex12 = Complex.valueOf(Double.POSITIVE_INFINITY);
complex10.negate();
complex12.getField();
complex9.ZERO.cos();
Complex complex13 = complex1.createComplex((-2762), (-859.5586949377));
complex13.acos();
complex11.add(1321.276);
Complex complex14 = complex6.reciprocal();
complex14.multiply(Double.POSITIVE_INFINITY);
Complex complex15 = complex4.atan();
Complex complex16 = Complex.valueOf((-859.5586949377), (-796.047));
complex15.add(complex16);
}
@Test(timeout = 4000)
public void test028() throws Throwable {
Complex complex0 = Complex.valueOf(0.1585290151921035, (-2888.65));
complex0.tan();
}
@Test(timeout = 4000)
public void test029() throws Throwable {
Complex complex0 = Complex.valueOf(1727.575, (-20.0));
complex0.readResolve();
complex0.sinh();
Complex complex1 = complex0.multiply(1313.407);
complex0.equals(complex1);
complex1.getArgument();
complex0.readResolve();
}
@Test(timeout = 4000)
public void test030() throws Throwable {
Complex complex0 = Complex.I;
Complex complex1 = complex0.ZERO.acos();
Complex complex2 = complex0.ZERO.multiply(complex1);
Complex complex3 = complex1.createComplex(3055.2234, 6.283185307179586);
Complex complex4 = Complex.ONE;
Complex complex5 = new Complex((-2335.91542), 3055.2234);
Complex complex6 = complex3.sqrt1z();
Complex complex7 = Complex.INF;
complex5.readResolve();
Complex complex8 = Complex.NaN;
Complex.valueOf(6.283185307179586);
complex1.equals(complex8);
Complex complex9 = complex5.cosh();
complex3.reciprocal();
complex9.cos();
complex3.readResolve();
complex6.reciprocal();
complex1.toString();
Complex complex10 = complex3.add(complex1);
Complex complex11 = complex10.ZERO.pow(complex0);
complex11.sqrt();
complex2.readResolve();
}
@Test(timeout = 4000)
public void test031() throws Throwable {
Complex complex0 = Complex.ZERO;
Complex complex1 = complex0.ZERO.exp();
complex1.ONE.multiply(2.9850404523368767E-171);
complex0.toString();
complex1.sqrt1z();
Complex complex2 = complex0.subtract(6.283185307179586);
complex2.hashCode();
Complex complex3 = Complex.INF;
complex3.reciprocal();
Complex complex4 = Complex.INF;
Complex complex5 = complex4.log();
Complex complex6 = Complex.INF;
complex6.isInfinite();
complex4.divide(6.283185307179586);
Complex complex7 = new Complex(2.9850404523368767E-171, 6.283185307179586);
Complex complex8 = Complex.INF;
complex8.getReal();
complex2.acos();
complex5.reciprocal();
}
@Test(timeout = 4000)
public void test032() throws Throwable {
Complex complex0 = Complex.valueOf((-3416.59699), (-5078.097));
assertNotNull(complex0);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
Complex complex1 = complex0.ZERO.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.ZERO.add(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.I.subtract(complex1);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(1.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals((-1.5707963267948966), complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex2.reciprocal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.6366197723675814, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
String string0 = complex4.ZERO.toString();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertEquals("(0.0, 0.0)", string0);
assertNotNull(string0);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.6366197723675814, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
Complex complex5 = complex0.conjugate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(5078.097, complex5.getImaginary(), 0.01);
assertEquals((-3416.59699), complex5.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
ComplexField complexField0 = complex5.I.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complexField0);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(5078.097, complex5.getImaginary(), 0.01);
assertEquals((-3416.59699), complex5.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
Complex complex6 = complex0.atan();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals((-1.5707051207504465), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.3555977887275285E-4), complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
Complex complex7 = Complex.valueOf((-3416.59699));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertNotNull(complex7);
assertEquals((-3416.59699), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
Complex complex8 = complex1.multiply(2347);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
Complex complex9 = complex8.ONE.negate();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals((-1.0), complex9.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
Complex complex10 = complex9.add(complex4);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.6366197723675814, complex4.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals((-1.0), complex9.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-0.3633802276324186), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex10);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex1);
String string1 = complex10.INF.toString();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex1));
assertFalse(string1.equals((Object)string0));
assertEquals("(Infinity, Infinity)", string1);
assertNotNull(string1);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.6366197723675814, complex4.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals((-1.0), complex9.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-0.3633802276324186), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex10);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex1);
Complex complex11 = complex8.atan();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex10));
assertNotNull(complex11);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertEquals(1.570525078496322, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex10);
Complex complex12 = complex11.INF.asin();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex6));
assertNotNull(complex12);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertEquals(1.570525078496322, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertTrue(complex12.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex6);
double double0 = complex11.getArgument();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex10));
assertEquals(0.0, double0, 0.01);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(3686.658978987622, complex8.getReal(), 0.01);
assertEquals(1.570525078496322, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex10);
Complex complex13 = complex0.ONE.conjugate();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex3));
assertNotNull(complex13);
assertEquals((-3416.59699), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-5078.097), complex0.getImaginary(), 0.01);
assertEquals(1.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex3);
// Undeclared exception!
complex0.nthRoot(2028417656);
}
@Test(timeout = 4000)
public void test033() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, Double.POSITIVE_INFINITY);
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
double double0 = complex0.getReal();
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.multiply(2147043365);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.sqrt();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = (Complex)complex1.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.multiply(1244.499245040559);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
Complex complex5 = complex4.cos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
Complex complex6 = complex1.ZERO.cos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
complex4.hashCode();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
double double1 = complex4.abs();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertNotEquals(double1, double0, 0.01);
assertEquals(Double.POSITIVE_INFINITY, double1, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
Complex complex7 = complex4.tanh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
Complex complex8 = complex4.conjugate();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
Complex complex9 = Complex.ZERO;
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
double double2 = complex2.getReal();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex5));
assertNotEquals(double2, double0, 0.01);
assertEquals(double2, double1, 0.01);
assertEquals(Double.POSITIVE_INFINITY, double2, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
Complex complex10 = complex7.multiply(complex5);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertTrue(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex9));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertNotNull(complex10);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex9);
assertSame(complex7, complex10);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertSame(complex10, complex7);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
Complex complex11 = Complex.I;
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex11);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex8);
Complex complex12 = Complex.I;
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertNotNull(complex12);
assertEquals(1.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertSame(complex12, complex11);
assertNotSame(complex12, complex4);
Complex complex13 = complex12.subtract(complex1);
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertNotNull(complex13);
assertEquals(1.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex13.getReal(), 0.01);
assertTrue(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex13.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex8);
assertSame(complex12, complex11);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex6);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
Complex complex14 = complex2.divide(complex7);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex0));
assertTrue(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertTrue(complex2.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex13));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex14);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(Double.NaN, complex14.getReal(), 0.01);
assertEquals(Double.NaN, complex14.getImaginary(), 0.01);
assertTrue(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex2);
assertSame(complex14, complex10);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex12);
assertSame(complex14, complex7);
assertNotSame(complex14, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex7, complex1);
assertSame(complex7, complex14);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex12);
assertSame(complex7, complex10);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
Complex complex15 = complex12.cosh();
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex14));
assertNotNull(complex15);
assertEquals(1.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex15.isInfinite());
assertEquals(0.5403023058681398, complex15.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex14);
assertSame(complex12, complex11);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex14);
Complex complex16 = new Complex(2.9850404523368767E-171, (-361.81571));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex0));
assertNotNull(complex16);
assertFalse(complex16.isNaN());
assertFalse(complex16.isInfinite());
assertEquals((-361.81571), complex16.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex16.getReal(), 0.01);
Complex complex17 = (Complex)complex11.readResolve();
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex14));
assertTrue(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex13));
assertTrue(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex17);
assertEquals(0.0, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(1.0, complex17.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex15);
assertSame(complex11, complex12);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex17);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex4);
Complex complex18 = Complex.I;
assertTrue(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex16));
assertNotNull(complex18);
assertFalse(complex18.isInfinite());
assertEquals(1.0, complex18.getImaginary(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getReal(), 0.01);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex10);
assertSame(complex18, complex12);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex8);
assertSame(complex18, complex11);
assertNotSame(complex18, complex16);
Complex complex19 = complex18.asin();
assertTrue(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex1));
assertNotNull(complex19);
assertFalse(complex18.isInfinite());
assertEquals(1.0, complex18.getImaginary(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getReal(), 0.01);
assertEquals(0.8813735870195428, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getReal(), 0.01);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex10);
assertSame(complex18, complex12);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex19);
assertNotSame(complex18, complex8);
assertSame(complex18, complex11);
assertNotSame(complex18, complex16);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex1);
Complex complex20 = complex1.acos();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex3));
assertTrue(complex20.equals((Object)complex2));
assertTrue(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex19));
assertNotNull(complex20);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex20.isNaN());
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex3);
assertSame(complex20, complex14);
assertSame(complex20, complex7);
assertNotSame(complex20, complex4);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex12);
assertSame(complex20, complex10);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex19);
complex10.hashCode();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex13));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex15));
assertTrue(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex18));
assertTrue(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex20));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex4));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex15));
assertTrue(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex20);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex20);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex3);
assertNotSame(complex7, complex1);
assertSame(complex7, complex14);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex18);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex5);
assertSame(complex7, complex20);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex16);
assertSame(complex7, complex10);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex19);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex4);
assertSame(complex10, complex7);
assertNotSame(complex10, complex5);
assertSame(complex10, complex20);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex16);
assertSame(complex10, complex14);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
Complex complex21 = Complex.NaN;
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex12));
assertTrue(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex0));
assertTrue(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex6));
assertNotNull(complex21);
assertFalse(complex21.isInfinite());
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertTrue(complex21.isNaN());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex0);
assertSame(complex21, complex10);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex19);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex3);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex1);
assertSame(complex21, complex14);
assertNotSame(complex21, complex15);
assertSame(complex21, complex7);
assertSame(complex21, complex20);
assertNotSame(complex21, complex4);
assertNotSame(complex21, complex6);
Complex complex22 = complex8.sqrt1z();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex13));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex1));
assertTrue(complex22.equals((Object)complex2));
assertTrue(complex22.equals((Object)complex14));
assertTrue(complex22.equals((Object)complex21));
assertTrue(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex0));
assertTrue(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex15));
assertTrue(complex22.equals((Object)complex7));
assertTrue(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex18));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex19));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex21));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex20));
assertNotNull(complex22);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.NaN, complex22.getReal(), 0.01);
assertFalse(complex22.isInfinite());
assertTrue(complex22.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex22.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex22);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex22);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex21);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex20);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex21);
assertNotSame(complex4, complex22);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex22, complex16);
assertNotSame(complex22, complex13);
assertNotSame(complex22, complex19);
assertNotSame(complex22, complex2);
assertNotSame(complex22, complex21);
assertNotSame(complex22, complex11);
assertNotSame(complex22, complex8);
assertNotSame(complex22, complex1);
assertNotSame(complex22, complex14);
assertNotSame(complex22, complex7);
assertNotSame(complex22, complex10);
assertNotSame(complex22, complex20);
assertNotSame(complex22, complex0);
assertNotSame(complex22, complex4);
assertNotSame(complex22, complex6);
assertNotSame(complex22, complex18);
assertNotSame(complex22, complex17);
assertNotSame(complex22, complex15);
assertNotSame(complex22, complex5);
assertNotSame(complex22, complex3);
assertNotSame(complex22, complex9);
assertNotSame(complex22, complex12);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex18);
assertNotSame(complex8, complex17);
assertNotSame(complex8, complex19);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex21);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex22);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex20);
Complex complex23 = complex8.cosh();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex13));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex22));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex18));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex19));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex21));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex22));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex16));
assertTrue(complex23.equals((Object)complex20));
assertTrue(complex23.equals((Object)complex7));
assertTrue(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex13));
assertTrue(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex15));
assertTrue(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex6));
assertTrue(complex23.equals((Object)complex2));
assertTrue(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex1));
assertTrue(complex23.equals((Object)complex21));
assertNotNull(complex23);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(Double.NaN, complex23.getImaginary(), 0.01);
assertFalse(complex23.isInfinite());
assertEquals(Double.NaN, complex23.getReal(), 0.01);
assertTrue(complex23.isNaN());
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex22);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex23);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex22);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex23);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex20);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex23);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex21);
assertNotSame(complex4, complex22);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex6);
assertSame(complex4, complex1);
assertNotSame(complex8, complex23);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex18);
assertNotSame(complex8, complex17);
assertNotSame(complex8, complex19);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex21);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex22);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex20);
assertNotSame(complex23, complex8);
assertNotSame(complex23, complex21);
assertNotSame(complex23, complex22);
assertNotSame(complex23, complex3);
assertNotSame(complex23, complex2);
assertNotSame(complex23, complex14);
assertNotSame(complex23, complex19);
assertNotSame(complex23, complex16);
assertNotSame(complex23, complex10);
assertNotSame(complex23, complex11);
assertNotSame(complex23, complex13);
assertNotSame(complex23, complex17);
assertNotSame(complex23, complex9);
assertNotSame(complex23, complex12);
assertNotSame(complex23, complex18);
assertNotSame(complex23, complex15);
assertNotSame(complex23, complex5);
assertNotSame(complex23, complex4);
assertNotSame(complex23, complex0);
assertNotSame(complex23, complex20);
assertNotSame(complex23, complex6);
assertNotSame(complex23, complex7);
assertNotSame(complex23, complex1);
Complex complex24 = complex1.reciprocal();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex7));
assertFalse(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex10));
assertFalse(complex24.equals((Object)complex11));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex2));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex1));
assertNotNull(complex24);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(0.0, complex24.getReal(), 0.01);
assertFalse(complex24.isNaN());
assertEquals(0.0, complex24.getImaginary(), 0.01);
assertFalse(complex24.isInfinite());
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex22);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex23);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex24);
assertNotSame(complex0, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex24);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex22);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex23);
assertNotSame(complex24, complex12);
assertNotSame(complex24, complex20);
assertNotSame(complex24, complex17);
assertNotSame(complex24, complex4);
assertNotSame(complex24, complex7);
assertNotSame(complex24, complex18);
assertNotSame(complex24, complex6);
assertNotSame(complex24, complex23);
assertNotSame(complex24, complex5);
assertNotSame(complex24, complex10);
assertNotSame(complex24, complex11);
assertNotSame(complex24, complex13);
assertNotSame(complex24, complex0);
assertNotSame(complex24, complex15);
assertNotSame(complex24, complex8);
assertNotSame(complex24, complex19);
assertSame(complex24, complex9);
assertNotSame(complex24, complex14);
assertNotSame(complex24, complex2);
assertNotSame(complex24, complex21);
assertNotSame(complex24, complex3);
assertNotSame(complex24, complex22);
assertNotSame(complex24, complex16);
assertNotSame(complex24, complex1);
}
@Test(timeout = 4000)
public void test034() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.ZERO.exp();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.multiply(2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.NaN.createComplex((-2335.91542), 2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = Complex.ONE;
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.0, complex4.getReal(), 0.01);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
Complex complex5 = complex2.acos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
Complex complex6 = complex2.sqrt1z();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
Complex complex7 = complex6.ONE.add(complex5);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(2.5707963267948966, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
double double0 = complex6.abs();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex7));
assertEquals(1.0, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
Complex complex8 = complex6.tanh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(0.7615941559557649, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex7);
Complex complex9 = complex2.conjugate();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertFalse(complex9.isInfinite());
assertEquals(2.9850404523368767E-171, complex9.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex4);
Complex complex10 = Complex.ZERO;
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(0.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertSame(complex10, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex5);
Complex complex11 = new Complex((-657.888885613609));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex11);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertEquals((-657.888885613609), complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
double double1 = complex11.getReal();
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertNotEquals(double1, double0, 0.01);
assertEquals((-657.888885613609), double1, 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertEquals((-657.888885613609), complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
Complex complex12 = complex6.multiply(complex2);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex10));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex10));
assertTrue(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex6));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(2.9850404523368767E-171, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex6);
Complex complex13 = Complex.I;
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertNotNull(complex13);
assertFalse(complex13.isNaN());
assertEquals(1.0, complex13.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
Complex complex14 = complex8.subtract(complex9);
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex13));
assertTrue(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertTrue(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex10));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex14);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.7615941559557649, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(0.7615941559557649, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex9.isNaN());
assertFalse(complex9.isInfinite());
assertEquals(2.9850404523368767E-171, complex9.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex13);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex1);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex4);
Complex complex15 = Complex.I;
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex12));
assertNotNull(complex15);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertEquals(0.0, complex15.getReal(), 0.01);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex14);
assertSame(complex15, complex13);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex12);
Complex complex16 = complex5.divide(complex15);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex6));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertEquals(0.0, complex15.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals((-1.5707963267948966), complex16.getImaginary(), 0.01);
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex16);
assertSame(complex15, complex13);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex16);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex11);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex13);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex6);
Complex complex17 = complex0.cosh();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex9));
assertTrue(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex13));
assertTrue(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex3));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(1.0, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex1);
Complex complex18 = new Complex(1.3134287685114547E204, 1.6136772632598877);
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex3));
assertNotNull(complex18);
assertEquals(1.6136772632598877, complex18.getImaginary(), 0.01);
assertFalse(complex18.isNaN());
assertFalse(complex18.isInfinite());
assertEquals(1.3134287685114547E204, complex18.getReal(), 0.01);
Complex complex19 = (Complex)complex4.readResolve();
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex8));
assertTrue(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex12));
assertTrue(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex3));
assertTrue(complex19.equals((Object)complex17));
assertTrue(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex16));
assertTrue(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex18));
assertNotNull(complex19);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.0, complex4.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(1.0, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex19.isNaN());
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex18);
Complex complex20 = complex4.asin();
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertTrue(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex8));
assertTrue(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex12));
assertTrue(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex3));
assertNotNull(complex20);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.0, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(-0.0, complex20.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex20);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex4);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex3);
Complex complex21 = complex18.acos();
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex20));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex19));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex0));
assertNotNull(complex21);
assertEquals(1.6136772632598877, complex18.getImaginary(), 0.01);
assertFalse(complex18.isNaN());
assertFalse(complex18.isInfinite());
assertEquals(1.3134287685114547E204, complex18.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex21.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex21.getReal(), 0.01);
assertFalse(complex21.isNaN());
assertTrue(complex21.isInfinite());
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex20);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex21);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex19);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex3);
assertNotSame(complex21, complex15);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex7);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex6);
assertNotSame(complex21, complex10);
assertNotSame(complex21, complex4);
assertNotSame(complex21, complex14);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex1);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex20);
assertNotSame(complex21, complex19);
assertNotSame(complex21, complex3);
assertNotSame(complex21, complex0);
complex18.hashCode();
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex20));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex21));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex19));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex3));
assertEquals(1.6136772632598877, complex18.getImaginary(), 0.01);
assertFalse(complex18.isNaN());
assertFalse(complex18.isInfinite());
assertEquals(1.3134287685114547E204, complex18.getReal(), 0.01);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex20);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex21);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex19);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex3);
Complex complex22 = Complex.NaN;
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex16));
assertNotNull(complex22);
assertEquals(Double.NaN, complex22.getReal(), 0.01);
assertEquals(Double.NaN, complex22.getImaginary(), 0.01);
assertFalse(complex22.isInfinite());
assertTrue(complex22.isNaN());
assertNotSame(complex22, complex2);
assertNotSame(complex22, complex15);
assertNotSame(complex22, complex10);
assertNotSame(complex22, complex7);
assertNotSame(complex22, complex6);
assertNotSame(complex22, complex11);
assertNotSame(complex22, complex20);
assertNotSame(complex22, complex3);
assertNotSame(complex22, complex0);
assertNotSame(complex22, complex13);
assertNotSame(complex22, complex17);
assertNotSame(complex22, complex1);
assertNotSame(complex22, complex9);
assertNotSame(complex22, complex19);
assertNotSame(complex22, complex8);
assertNotSame(complex22, complex14);
assertNotSame(complex22, complex5);
assertNotSame(complex22, complex18);
assertNotSame(complex22, complex21);
assertNotSame(complex22, complex4);
assertNotSame(complex22, complex12);
assertNotSame(complex22, complex16);
Complex complex23 = complex6.sqrt1z();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex20));
assertTrue(complex1.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex17));
assertTrue(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex22));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex21));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex21));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex20));
assertFalse(complex6.equals((Object)complex18));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex22));
assertTrue(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex13));
assertTrue(complex6.equals((Object)complex19));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex11));
assertTrue(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex18));
assertTrue(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex9));
assertTrue(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex16));
assertNotNull(complex23);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex23.isInfinite());
assertEquals(0.0, complex23.getImaginary(), 0.01);
assertEquals(0.0, complex23.getReal(), 0.01);
assertFalse(complex23.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex22);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex23);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex22);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex23);
assertNotSame(complex1, complex17);
assertNotSame(complex2, complex20);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex23);
assertNotSame(complex2, complex19);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex22);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex21);
assertNotSame(complex2, complex13);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex21);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex20);
assertNotSame(complex6, complex18);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex23);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex22);
assertNotSame(complex6, complex19);
assertNotSame(complex6, complex17);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex23, complex4);
assertNotSame(complex23, complex11);
assertNotSame(complex23, complex8);
assertNotSame(complex23, complex7);
assertNotSame(complex23, complex15);
assertNotSame(complex23, complex2);
assertNotSame(complex23, complex0);
assertNotSame(complex23, complex3);
assertNotSame(complex23, complex20);
assertNotSame(complex23, complex18);
assertNotSame(complex23, complex14);
assertNotSame(complex23, complex5);
assertNotSame(complex23, complex17);
assertNotSame(complex23, complex6);
assertNotSame(complex23, complex10);
assertNotSame(complex23, complex22);
assertNotSame(complex23, complex19);
assertNotSame(complex23, complex13);
assertNotSame(complex23, complex1);
assertNotSame(complex23, complex21);
assertNotSame(complex23, complex9);
assertNotSame(complex23, complex12);
assertNotSame(complex23, complex16);
Complex complex24 = complex2.cosh();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex15));
assertTrue(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex20));
assertTrue(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex23));
assertFalse(complex2.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex17));
assertTrue(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex23));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex22));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex21));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex16));
assertTrue(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex23));
assertTrue(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex10));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex22));
assertTrue(complex24.equals((Object)complex6));
assertTrue(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex11));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex2));
assertTrue(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex7));
assertFalse(complex24.equals((Object)complex3));
assertNotNull(complex24);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex24.isNaN());
assertFalse(complex24.isInfinite());
assertEquals(0.0, complex24.getImaginary(), 0.01);
assertEquals(1.0, complex24.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex22);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex24);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex23);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex22);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex24);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex23);
assertNotSame(complex2, complex20);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex24);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex23);
assertNotSame(complex2, complex19);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex22);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex21);
assertNotSame(complex2, complex13);
assertNotSame(complex24, complex16);
assertNotSame(complex24, complex20);
assertNotSame(complex24, complex14);
assertNotSame(complex24, complex23);
assertNotSame(complex24, complex6);
assertNotSame(complex24, complex5);
assertNotSame(complex24, complex10);
assertNotSame(complex24, complex17);
assertNotSame(complex24, complex13);
assertNotSame(complex24, complex15);
assertNotSame(complex24, complex22);
assertNotSame(complex24, complex1);
assertNotSame(complex24, complex12);
assertNotSame(complex24, complex9);
assertNotSame(complex24, complex18);
assertNotSame(complex24, complex21);
assertNotSame(complex24, complex8);
assertNotSame(complex24, complex11);
assertNotSame(complex24, complex19);
assertNotSame(complex24, complex4);
assertNotSame(complex24, complex0);
assertNotSame(complex24, complex2);
assertNotSame(complex24, complex7);
assertNotSame(complex24, complex3);
}
@Test(timeout = 4000)
public void test035() throws Throwable {
Complex complex0 = Complex.valueOf((-1860.184878956501));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.INF.multiply((-1));
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.reciprocal();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.tan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-5.375810262967398E-4), complex3.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.NaN.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex2.sinh();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-5.375810004038505E-4), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
ComplexField complexField0 = complex2.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
Complex complex6 = (Complex)complex1.readResolve();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex6.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
complex5.hashCode();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-5.375810004038505E-4), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
Complex complex7 = complex1.createComplex(Double.POSITIVE_INFINITY, 1829.05503);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex7.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex7.getReal(), 0.01);
assertEquals(1829.05503, complex7.getImaginary(), 0.01);
assertTrue(complex7.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
Complex complex8 = complex2.atan();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex8.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex7);
Complex complex9 = complex2.divide(complex7);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex7.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex7.getReal(), 0.01);
assertEquals(1829.05503, complex7.getImaginary(), 0.01);
assertTrue(complex7.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
Complex complex10 = complex9.INF.subtract(complex3);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex6));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-5.375810262967398E-4), complex3.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex7.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex7.getReal(), 0.01);
assertEquals(1829.05503, complex7.getImaginary(), 0.01);
assertTrue(complex7.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertTrue(complex10.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex7);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
Complex complex11 = complex8.conjugate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertTrue(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex8.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(-0.0, complex11.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex11.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex7);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
Object object0 = new Object();
assertNotNull(object0);
boolean boolean0 = complex7.equals(object0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex7.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex7.getReal(), 0.01);
assertEquals(1829.05503, complex7.getImaginary(), 0.01);
assertTrue(complex7.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
Complex complex12 = complex5.pow(435.27893453);
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex12);
assertFalse(complex12.isNaN());
assertEquals(-0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-5.375810004038505E-4), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex0);
Complex complex13 = complex2.subtract((-2463.6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(2463.5994624190253, complex13.getReal(), 0.01);
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex1);
Complex complex14 = complex11.subtract(complex12);
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex0));
assertTrue(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex6));
assertTrue(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex12));
assertTrue(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex14);
assertFalse(complex12.isNaN());
assertEquals(-0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-5.375810004038505E-4), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex8.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(-0.0, complex11.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex11.getReal(), 0.01);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex14);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex10);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex6);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex14);
Complex complex15 = complex14.NaN.multiply(435.27893453);
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex14.equals((Object)complex0));
assertTrue(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex6));
assertTrue(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex11));
assertTrue(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex5));
assertTrue(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex12));
assertTrue(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex15);
assertFalse(complex12.isNaN());
assertEquals(-0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertTrue(complex15.isNaN());
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-5.375810004038505E-4), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex8.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(-0.0, complex11.getImaginary(), 0.01);
assertEquals((-5.37580922725208E-4), complex11.getReal(), 0.01);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex14);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex1);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex9);
assertSame(complex15, complex4);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex10);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex15);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex14);
Complex complex16 = complex12.reciprocal();
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex10));
assertNotNull(complex16);
assertFalse(complex12.isNaN());
assertEquals(-0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertTrue(complex16.isNaN());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-5.375810004038505E-4), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex16);
assertNotSame(complex12, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex14);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex1);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex11);
assertSame(complex16, complex15);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex7);
assertSame(complex16, complex4);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex6);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex16);
Complex complex17 = complex13.multiply(complex0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex7));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1860.184878956501), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(2463.5994624190253, complex13.getReal(), 0.01);
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-5.375809745109665E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex17.isInfinite());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertEquals((-4582750.467797236), complex17.getReal(), 0.01);
assertFalse(complex17.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex14);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex1);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex7);
}
@Test(timeout = 4000)
public void test036() throws Throwable {
Complex complex0 = Complex.valueOf(0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.INF.add(0.0);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
complex0.hashCode();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertNotSame(complex0, complex1);
Complex complex2 = complex0.I.pow(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertTrue(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex1.sqrt();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.I.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isNaN());
assertEquals((-1.0), complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
Complex complex5 = complex1.acos();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
double double0 = complex2.getReal();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertEquals(Double.NaN, double0, 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertTrue(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
Complex complex6 = complex3.add(0.0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isNaN());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertSame(complex6, complex5);
Complex complex7 = Complex.valueOf(Double.NaN, 2.6735267639160156);
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
boolean boolean0 = complex7.equals(complex1);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
double double1 = complex5.getArgument();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertEquals(double1, double0, 0.01);
assertEquals(Double.NaN, double1, 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
Complex complex8 = (Complex)complex6.readResolve();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex6));
assertTrue(complex3.equals((Object)complex5));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex7));
assertTrue(complex8.equals((Object)complex2));
assertTrue(complex8.equals((Object)complex6));
assertTrue(complex8.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isNaN());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertSame(complex6, complex7);
assertSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
}
@Test(timeout = 4000)
public void test037() throws Throwable {
Complex complex0 = new Complex((-1728.66484955));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
Complex complex1 = complex0.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.createComplex(0, 797.126739284144);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
Complex complex4 = complex3.NaN.acos();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
ComplexField complexField0 = complex2.INF.getField();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
Complex complex5 = complex2.I.multiply(0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
Complex complex6 = complex4.add(797.126739284144);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertTrue(complex6.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertSame(complex4, complex6);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex6, complex0);
assertSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
Complex complex7 = complex4.acos();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertSame(complex4, complex6);
assertNotSame(complex4, complex2);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertSame(complex7, complex4);
Complex complex8 = complex2.sqrt1z();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.1185991879167819, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
Complex complex9 = complex2.add(complex0);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-1729.671857875375), complex9.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
Complex complex10 = (Complex)complex0.readResolve();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-1728.66484955), complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
Complex complex11 = Complex.ONE;
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex3));
assertNotNull(complex11);
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex3);
boolean boolean0 = complex11.equals(complex7);
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex3));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex10);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertSame(complex4, complex6);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex9);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex11);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex9);
assertSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertSame(complex7, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex3);
Complex complex12 = complex9.cosh();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertTrue(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-1729.671857875375), complex9.getReal(), 0.01);
assertTrue(complex12.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
Complex complex13 = complex3.reciprocal();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex13.isInfinite());
assertEquals((-0.0012545056522605745), complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex10);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
Complex complex14 = complex9.tan();
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex14);
assertEquals(4.367140354555913, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-1729.671857875375), complex9.getReal(), 0.01);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
Complex complex15 = complex5.asin();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertTrue(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex6));
assertNotNull(complex15);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.0, complex15.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex14);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex6);
Complex complex16 = Complex.I;
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertNotNull(complex16);
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals(1.0, complex16.getImaginary(), 0.01);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex5);
Complex complex17 = complex16.createComplex(131765.39604569002, (-2928.801213026698));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertNotNull(complex17);
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals(1.0, complex16.getImaginary(), 0.01);
assertEquals(131765.39604569002, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals((-2928.801213026698), complex17.getImaginary(), 0.01);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex17);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex5);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex5);
Complex complex18 = complex15.conjugate();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertTrue(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex13));
assertTrue(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex9));
assertTrue(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex6));
assertNotNull(complex18);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.0, complex15.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getReal(), 0.01);
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex18);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex17);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex0);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex6);
String string0 = complex13.toString();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertEquals("(0.0, -0.0012545056522605745)", string0);
assertNotNull(string0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex13.isInfinite());
assertEquals((-0.0012545056522605745), complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex10);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex18);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
Complex complex19 = complex16.pow(complex3);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex17));
assertTrue(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex0));
assertTrue(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex12));
assertTrue(complex19.equals((Object)complex15));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals(1.0, complex16.getImaginary(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.0, complex19.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex18);
assertNotSame(complex16, complex19);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex17);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex19);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex10);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex12);
double double0 = complex18.abs();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertTrue(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex17));
assertTrue(complex15.equals((Object)complex18));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex8));
assertTrue(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex13));
assertTrue(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex9));
assertTrue(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex12));
assertTrue(complex18.equals((Object)complex19));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertTrue(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex6));
assertEquals(0.0, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.0, complex15.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getReal(), 0.01);
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex19);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex18);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex19);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex17);
assertNotSame(complex18, complex19);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex0);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex6);
Complex complex20 = complex14.subtract(2428.509);
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex19));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex19));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex18));
assertNotNull(complex20);
assertEquals(4.367140354555913, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals((-2424.141859645444), complex20.getReal(), 0.01);
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex20.isNaN());
assertFalse(complex20.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-1729.671857875375), complex9.getReal(), 0.01);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex19);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex20);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex2, complex20);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex19);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex17);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex4);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex5);
assertNotSame(complex9, complex19);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex17);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex20);
assertNotSame(complex9, complex18);
}
@Test(timeout = 4000)
public void test038() throws Throwable {
Complex complex0 = Complex.valueOf((-2438.256513));
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.multiply((-2438.256513));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = complex1.NaN.pow(complex0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
Complex complex5 = complex4.NaN.negate();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
Complex complex6 = complex1.sqrt1z();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
Complex complex7 = complex6.I.atan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertSame(complex7, complex4);
assertNotSame(complex7, complex0);
Complex complex8 = complex1.NaN.add(complex7);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertSame(complex7, complex8);
assertSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex8, complex2);
assertSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertSame(complex8, complex5);
assertNotSame(complex8, complex3);
Complex complex9 = complex6.ZERO.log();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertNotNull(complex9);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex0);
Complex complex10 = complex0.multiply(complex6);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals((-7613.650176966752), complex10.getImaginary(), 0.01);
assertEquals((-20832.204028784934), complex10.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex5);
Complex complex11 = complex6.I.add(complex3);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex10));
assertNotNull(complex11);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(5945094.823186918, complex11.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex0);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex10);
Complex complex12 = complex1.subtract(complex3);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(complex12);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals((-5945091.681594265), complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals((-8.492185657535124), complex12.getImaginary(), 0.01);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex0);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex11);
double double0 = complex9.getImaginary();
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex10));
assertEquals(0.0, double0, 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex10);
Complex complex13 = Complex.NaN;
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex12));
assertNotNull(complex13);
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex6);
assertSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertSame(complex13, complex5);
assertSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex0);
assertSame(complex13, complex8);
assertNotSame(complex13, complex12);
boolean boolean0 = complex10.equals(complex13);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex12));
assertFalse(boolean0);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals((-7613.650176966752), complex10.getImaginary(), 0.01);
assertEquals((-20832.204028784934), complex10.getReal(), 0.01);
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex13);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex6);
assertSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertSame(complex13, complex5);
assertSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex0);
assertSame(complex13, complex8);
assertNotSame(complex13, complex12);
Complex complex14 = complex2.sinh();
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertNotNull(complex14);
assertFalse(complex14.isInfinite());
assertEquals(0.005525782205542805, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(1.1768576043096548, complex14.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
Complex complex15 = complex1.cos();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertNotNull(complex15);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals((-2438.256512999999), complex15.getReal(), 0.01);
assertEquals(2.9860027830139674E-13, complex15.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
Complex complex16 = complex9.conjugate();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex10));
assertNotNull(complex16);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertTrue(complex16.isInfinite());
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex16.getReal(), 0.01);
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex13);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex15);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex10);
Complex complex17 = (Complex)complex13.readResolve();
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex12));
assertTrue(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex16));
assertTrue(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex14));
assertTrue(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex15));
assertTrue(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex9));
assertTrue(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex16));
assertNotNull(complex17);
assertEquals(Double.NaN, complex17.getReal(), 0.01);
assertEquals(Double.NaN, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertTrue(complex17.isNaN());
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex3);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex6);
assertSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertSame(complex13, complex5);
assertSame(complex13, complex4);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex14);
assertSame(complex13, complex8);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex16);
Complex complex18 = complex16.reciprocal();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex15));
assertTrue(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex10));
assertNotNull(complex18);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertTrue(complex16.isInfinite());
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex16.getReal(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertEquals(0.0, complex18.getReal(), 0.01);
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex15);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex17);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex18);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex13);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex17);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex18);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex18);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex17);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex10);
String string0 = complex7.toString();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex12));
assertTrue(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertEquals("(NaN, NaN)", string0);
assertNotNull(string0);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex14);
Complex complex19 = complex15.add(complex5);
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex0));
assertTrue(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex6));
assertNotNull(complex19);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals((-2438.256512999999), complex15.getReal(), 0.01);
assertEquals(2.9860027830139674E-13, complex15.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertTrue(complex19.isNaN());
Complex complex20 = complex11.conjugate();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex19));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex18));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex19));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertNotNull(complex20);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertFalse(complex20.isInfinite());
assertEquals(5945094.823186918, complex20.getReal(), 0.01);
assertEquals((-1.0), complex20.getImaginary(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(5945094.823186918, complex11.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex11.isInfinite());
Complex complex21 = complex10.asin();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex20));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex19));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex20));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex15));
assertNotNull(complex21);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-10.70008936923665), complex21.getImaginary(), 0.01);
assertEquals((-1.2204023602237648), complex21.getReal(), 0.01);
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals((-7613.650176966752), complex10.getImaginary(), 0.01);
assertEquals((-20832.204028784934), complex10.getReal(), 0.01);
boolean boolean1 = complex5.equals(complex19);
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex20));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex21));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex21));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex20));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex21));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex20));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex0));
assertTrue(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex6));
assertFalse(boolean1 == boolean0);
assertTrue(boolean1);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals((-2438.256512999999), complex15.getReal(), 0.01);
assertEquals(2.9860027830139674E-13, complex15.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertTrue(complex19.isNaN());
Complex complex22 = complex1.exp();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex11));
assertNotNull(complex22);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-13.78615866955364), complex22.getReal(), 0.01);
assertEquals((-18.585840972704347), complex22.getImaginary(), 0.01);
assertFalse(complex22.isInfinite());
assertFalse(complex22.isNaN());
}
@Test(timeout = 4000)
public void test039() throws Throwable {
Complex complex0 = Complex.valueOf(0.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.asin();
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.atan();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex1.exp();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex0.negate();
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(-0.0, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
ComplexField complexField0 = complex4.getField();
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(-0.0, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
ComplexField complexField1 = complex1.getField();
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex2));
assertNotNull(complexField1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertSame(complexField1, complexField0);
Complex complex5 = Complex.valueOf(0.0);
assertTrue(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
Complex complex6 = complex5.ONE.add(complex3);
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(2.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
Complex complex7 = null;
try {
complex5.divide((Complex) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// null is not allowed
//
verifyException("org.apache.commons.math3.util.MathUtils", e);
}
}
@Test(timeout = 4000)
public void test040() throws Throwable {
double double0 = (-2438.256513);
Complex complex0 = Complex.valueOf((-2438.256513));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.multiply((-2438.256513));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.NaN.pow(complex0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
Complex complex5 = complex4.NaN.negate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex5);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex2);
assertSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
Complex complex6 = complex1.sqrt1z();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
Complex complex7 = complex6.I.atan();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex7, complex3);
assertSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
double double1 = complex0.getReal();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertEquals(double1, double0, 0.01);
assertEquals((-2438.256513), double1, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
boolean boolean0 = complex2.isInfinite();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
Complex complex8 = complex4.multiply(363);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertTrue(complex8.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
assertSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertSame(complex8, complex7);
Complex complex9 = complex5.sqrt();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertSame(complex4, complex9);
assertNotSame(complex5, complex2);
assertSame(complex5, complex8);
assertSame(complex5, complex7);
assertSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertSame(complex5, complex9);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex9, complex0);
assertSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertSame(complex9, complex8);
assertSame(complex9, complex7);
assertSame(complex9, complex4);
assertNotSame(complex9, complex3);
Complex complex10 = (Complex)complex9.readResolve();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertTrue(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertTrue(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertTrue(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertSame(complex4, complex9);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex2);
assertSame(complex5, complex8);
assertSame(complex5, complex7);
assertSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertSame(complex5, complex9);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex9, complex0);
assertSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex10);
assertSame(complex9, complex8);
assertSame(complex9, complex7);
assertSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex7);
Complex complex11 = complex3.sqrt1z();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals(5945094.823186833, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
Complex complex12 = complex6.add(complex8);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex10));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex1);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertSame(complex4, complex9);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex5);
assertNotSame(complex8, complex1);
assertSame(complex8, complex9);
assertSame(complex8, complex5);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
assertSame(complex8, complex12);
assertNotSame(complex8, complex6);
assertSame(complex8, complex4);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex3);
assertSame(complex8, complex7);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex2);
assertSame(complex12, complex8);
assertSame(complex12, complex5);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex3);
assertSame(complex12, complex4);
assertNotSame(complex12, complex6);
assertSame(complex12, complex9);
assertSame(complex12, complex7);
Complex complex13 = (Complex)complex12.readResolve();
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex10));
assertTrue(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex2));
assertTrue(complex13.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex7));
assertTrue(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex10));
assertNotNull(complex13);
assertTrue(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex10);
assertSame(complex4, complex7);
assertSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex1);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex8, complex1);
assertSame(complex8, complex9);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex0);
assertSame(complex8, complex4);
assertNotSame(complex8, complex10);
assertSame(complex8, complex7);
assertSame(complex8, complex5);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex2);
assertSame(complex8, complex12);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex2);
assertSame(complex12, complex8);
assertSame(complex12, complex5);
assertSame(complex12, complex4);
assertSame(complex12, complex9);
assertSame(complex12, complex7);
boolean boolean1 = complex10.equals(complex4);
assertFalse(boolean1 == boolean0);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex11));
assertTrue(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex6));
assertTrue(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex10));
assertTrue(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex7));
assertTrue(complex10.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex13));
assertTrue(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex1));
assertTrue(complex10.equals((Object)complex9));
assertTrue(complex10.equals((Object)complex5));
assertTrue(boolean1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex10);
assertSame(complex4, complex7);
assertSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex1);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex11);
assertSame(complex5, complex8);
assertNotSame(complex5, complex3);
assertSame(complex5, complex12);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex6);
assertSame(complex5, complex7);
assertSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertSame(complex9, complex12);
assertSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex10);
assertSame(complex9, complex7);
assertSame(complex9, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
Complex complex14 = complex1.cosh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertNotNull(complex14);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-6.905951765679634), complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertEquals((-9.275566489533594), complex14.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
Complex complex15 = complex9.reciprocal();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex14));
assertTrue(complex15.equals((Object)complex10));
assertTrue(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex14));
assertTrue(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex6));
assertTrue(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex10));
assertTrue(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex15);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertTrue(complex15.isNaN());
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertSame(complex15, complex8);
assertSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex2);
assertSame(complex15, complex7);
assertSame(complex15, complex9);
assertSame(complex15, complex4);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex3);
assertSame(complex15, complex12);
assertNotSame(complex15, complex11);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex10);
assertSame(complex4, complex15);
assertSame(complex4, complex7);
assertSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex1);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex11);
assertSame(complex5, complex8);
assertNotSame(complex5, complex3);
assertSame(complex5, complex12);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex14);
assertSame(complex5, complex15);
assertNotSame(complex5, complex6);
assertSame(complex5, complex7);
assertSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertSame(complex9, complex15);
assertSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertSame(complex9, complex12);
assertSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex10);
assertSame(complex9, complex7);
assertSame(complex9, complex4);
Complex complex16 = complex0.tan();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex5));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals((-0.40012463251770625), complex16.getReal(), 0.01);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex5);
Complex complex17 = Complex.ZERO;
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex5));
assertNotNull(complex17);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex5);
Complex complex18 = complex17.cos();
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex17));
assertNotNull(complex18);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(-0.0, complex18.getImaginary(), 0.01);
assertEquals(1.0, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertFalse(complex18.isInfinite());
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex18);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex5);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex17);
Complex complex19 = complex4.conjugate();
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex16));
assertTrue(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex6));
assertTrue(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex11));
assertTrue(complex19.equals((Object)complex10));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertTrue(complex19.isNaN());
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertSame(complex4, complex5);
assertSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex16);
assertSame(complex4, complex15);
assertSame(complex4, complex7);
assertSame(complex4, complex19);
assertSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex1);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex3);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex6);
assertSame(complex19, complex7);
assertNotSame(complex19, complex14);
assertSame(complex19, complex15);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex1);
assertSame(complex19, complex9);
assertSame(complex19, complex4);
assertSame(complex19, complex5);
assertSame(complex19, complex12);
assertSame(complex19, complex8);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex11);
try {
complex19.ZERO.pow((Complex) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// null is not allowed
//
verifyException("org.apache.commons.math3.util.MathUtils", e);
}
}
@Test(timeout = 4000)
public void test041() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.ONE.log();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.divide((-6300.9646));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex1.sin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = Complex.valueOf((-6300.9646));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
Complex complex5 = complex4.ZERO.tan();
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex1));
assertNotNull(complex5);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
Complex complex6 = complex1.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
Complex complex7 = complex6.I.multiply(complex5);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex6));
assertTrue(complex5.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
complex6.INF.hashCode();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex7));
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
Complex complex8 = complex3.sinh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex7));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex1));
assertTrue(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertTrue(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(0.0, complex8.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex8);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
boolean boolean0 = complex2.equals(complex3);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex6));
assertTrue(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex5));
assertFalse(boolean0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex8);
double double0 = complex7.getArgument();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex8));
assertTrue(complex5.equals((Object)complex6));
assertTrue(complex5.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex7));
assertTrue(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex8));
assertTrue(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
Complex complex9 = (Complex)complex8.readResolve();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex6));
assertTrue(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex7));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex1));
assertTrue(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertTrue(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex9.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertTrue(complex9.equals((Object)complex8));
assertTrue(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(0.0, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex8);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
}
@Test(timeout = 4000)
public void test042() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.sqrt1z();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.asin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.atan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
Complex complex4 = complex3.I.exp();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
Complex complex5 = complex3.INF.negate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
ComplexField complexField1 = complex4.ZERO.getField();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complexField1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertSame(complexField1, complexField0);
Complex complex6 = complex0.subtract(complex2);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
Complex complex7 = complex4.divide(complex0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-0.5403023058681398), complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.8414709848078965, complex7.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
Complex complex8 = complex6.tanh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.0333696651172133), complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.0813630257280234, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
Complex complex9 = complex6.cosh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
complex9.INF.hashCode();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
Complex complex10 = Complex.valueOf(Double.NaN);
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex3));
assertNotNull(complex10);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex3);
Complex complex11 = complex8.tanh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertNotNull(complex11);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.0333696651172133), complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.0813630257280234, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex11.isNaN());
assertFalse(complex11.isInfinite());
assertEquals((-0.7773047755527164), complex11.getReal(), 0.01);
assertEquals(0.03240435627323681, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
double double0 = complex0.getImaginary();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertEquals(1.0, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
double double1 = complex10.getArgument();
assertNotEquals(double1, double0, 0.01);
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex3));
assertEquals(Double.NaN, double1, 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex3);
}
@Test(timeout = 4000)
public void test043() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, 0.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.add((-905.41));
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-905.41), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
complex1.hashCode();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-905.41), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.pow(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-905.41), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.sqrt();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-905.41), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(30.09003157193425, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
Complex complex4 = complex1.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-905.41), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-905.41), complex4.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex0.acos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
double double0 = complex5.getReal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertEquals(1.5707963267948966, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
Complex complex6 = complex5.add((-609.0601332342465));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals((-607.4893369074515), complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
Complex complex7 = complex6.createComplex(0.0, 0.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals((-607.4893369074515), complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex4);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex1);
Complex complex8 = complex6.pow(1168.589432849974);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex1));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals((-607.4893369074515), complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getReal(), 0.01);
assertTrue(complex8.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getImaginary(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex4);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex1);
}
@Test(timeout = 4000)
public void test044() throws Throwable {
Complex complex0 = Complex.valueOf((-2438.256513));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.multiply((-2438.256513));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.NaN.pow(complex0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
Complex complex5 = complex4.NaN.negate();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
Complex complex6 = complex5.sqrt1z();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertSame(complex4, complex6);
assertNotSame(complex4, complex2);
assertSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex3);
assertSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
Complex complex7 = complex4.atan();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertSame(complex7, complex4);
assertSame(complex7, complex6);
assertNotSame(complex7, complex3);
Complex complex8 = new Complex(1171.5296931266785);
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertNotNull(complex8);
assertEquals(1171.5296931266785, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
Complex complex9 = complex8.add(complex2);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1171.5296931266785, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.003578075058834327, complex9.getImaginary(), 0.01);
assertEquals(1172.5307710101563, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
Complex complex10 = complex6.log();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex1);
assertSame(complex4, complex10);
assertNotSame(complex4, complex9);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex9);
assertSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex8);
assertSame(complex5, complex10);
assertNotSame(complex5, complex1);
assertSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex3);
assertSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertSame(complex10, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertSame(complex10, complex7);
Complex complex11 = complex8.multiply(complex2);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1171.5296931266785, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(4.191821175660401, complex11.getImaginary(), 0.01);
assertEquals(1172.7924656267228, complex11.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex8);
Complex complex12 = complex5.add(complex0);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex8));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertSame(complex4, complex10);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex11);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertSame(complex4, complex12);
assertSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex9);
assertSame(complex5, complex6);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex0);
assertSame(complex5, complex12);
assertSame(complex5, complex10);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertSame(complex12, complex7);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex2);
assertSame(complex12, complex5);
assertSame(complex12, complex6);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex1);
assertSame(complex12, complex4);
assertSame(complex12, complex10);
assertNotSame(complex12, complex8);
Complex complex13 = complex11.subtract(complex8);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex8));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1171.5296931266785, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(4.191821175660401, complex11.getImaginary(), 0.01);
assertEquals(1172.7924656267228, complex11.getReal(), 0.01);
assertEquals(4.191821175660401, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(1.2627725000443206, complex13.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex13);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex7);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex12);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex8);
double double0 = complex2.getImaginary();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex13));
assertEquals(0.003578075058834327, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex13);
Complex complex14 = Complex.NaN;
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex0));
assertNotNull(complex14);
assertEquals(Double.NaN, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertTrue(complex14.isNaN());
assertEquals(Double.NaN, complex14.getReal(), 0.01);
assertSame(complex14, complex10);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex11);
assertSame(complex14, complex7);
assertNotSame(complex14, complex1);
assertSame(complex14, complex12);
assertNotSame(complex14, complex13);
assertSame(complex14, complex6);
assertSame(complex14, complex4);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex0);
assertSame(complex14, complex5);
Complex complex15 = Complex.I;
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertNotNull(complex15);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex13);
boolean boolean0 = complex15.equals(complex13);
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex8));
assertFalse(boolean0);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1171.5296931266785, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(4.191821175660401, complex11.getImaginary(), 0.01);
assertEquals(1172.7924656267228, complex11.getReal(), 0.01);
assertEquals(4.191821175660401, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(1.2627725000443206, complex13.getReal(), 0.01);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex13);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex7);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex12);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex8);
Complex complex16 = complex12.sinh();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex8));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertTrue(complex16.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertSame(complex16, complex12);
assertNotSame(complex16, complex1);
assertSame(complex16, complex7);
assertNotSame(complex16, complex15);
assertSame(complex16, complex4);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex9);
assertSame(complex16, complex6);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex0);
assertSame(complex16, complex10);
assertNotSame(complex16, complex8);
assertSame(complex16, complex5);
assertSame(complex16, complex14);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex13);
assertNotSame(complex4, complex0);
assertSame(complex4, complex16);
assertSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertSame(complex4, complex10);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex2);
assertSame(complex4, complex12);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex9);
assertSame(complex4, complex14);
assertNotSame(complex4, complex11);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertNotSame(complex5, complex13);
assertSame(complex5, complex4);
assertNotSame(complex5, complex9);
assertSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertSame(complex5, complex12);
assertSame(complex5, complex10);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex15);
assertSame(complex5, complex16);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertSame(complex5, complex14);
assertSame(complex5, complex7);
assertSame(complex12, complex7);
assertNotSame(complex12, complex3);
assertSame(complex12, complex5);
assertSame(complex12, complex6);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex0);
assertSame(complex12, complex4);
assertSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertSame(complex12, complex14);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex8);
assertSame(complex12, complex16);
Complex complex17 = complex15.asin();
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex0));
assertNotNull(complex17);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(0.0, complex17.getReal(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(0.8813735870195428, complex17.getImaginary(), 0.01);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex16);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex0);
Complex complex18 = complex7.createComplex(1171.5296931266785, 0.16607704758644104);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex18);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(1171.5296931266785, complex18.getReal(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals(0.16607704758644104, complex18.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex16);
assertNotSame(complex4, complex0);
assertSame(complex4, complex16);
assertSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertSame(complex4, complex10);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex2);
assertSame(complex4, complex12);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex9);
assertSame(complex4, complex14);
assertNotSame(complex4, complex11);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertNotSame(complex7, complex1);
assertSame(complex7, complex12);
assertNotSame(complex7, complex13);
assertSame(complex7, complex14);
assertSame(complex7, complex16);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex9);
assertSame(complex7, complex4);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex18);
assertSame(complex7, complex10);
assertSame(complex7, complex6);
assertNotSame(complex7, complex3);
Complex complex19 = Complex.ZERO;
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex9));
assertNotNull(complex19);
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex9);
Complex complex20 = complex19.conjugate();
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex8));
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex4));
assertNotNull(complex20);
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(-0.0, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(0.0, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertNotSame(complex19, complex20);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex9);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex4);
String string0 = complex15.toString();
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex20));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex19));
assertEquals("(0.0, 1.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex18);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex20);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex19);
Complex complex21 = complex7.pow(complex4);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex1));
assertNotNull(complex21);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertTrue(complex21.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex20);
assertNotSame(complex4, complex0);
assertSame(complex4, complex16);
assertSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertSame(complex4, complex10);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex2);
assertSame(complex4, complex12);
assertSame(complex4, complex21);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex9);
assertSame(complex4, complex14);
assertNotSame(complex4, complex11);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertSame(complex7, complex21);
assertNotSame(complex7, complex1);
assertSame(complex7, complex12);
assertNotSame(complex7, complex13);
assertSame(complex7, complex14);
assertSame(complex7, complex16);
assertNotSame(complex7, complex19);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex20);
assertNotSame(complex7, complex9);
assertSame(complex7, complex4);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex18);
assertSame(complex7, complex10);
assertSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertSame(complex21, complex12);
assertNotSame(complex21, complex15);
assertSame(complex21, complex7);
assertNotSame(complex21, complex18);
assertSame(complex21, complex5);
assertSame(complex21, complex10);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex3);
assertSame(complex21, complex6);
assertSame(complex21, complex14);
assertSame(complex21, complex4);
assertNotSame(complex21, complex19);
assertNotSame(complex21, complex0);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex20);
assertNotSame(complex21, complex8);
assertSame(complex21, complex16);
assertNotSame(complex21, complex1);
double double1 = complex16.abs();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex20));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertNotEquals(double1, double0, 0.01);
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex8));
assertEquals(Double.NaN, double1, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertTrue(complex16.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertSame(complex16, complex12);
assertSame(complex16, complex21);
assertNotSame(complex16, complex18);
assertNotSame(complex16, complex1);
assertSame(complex16, complex7);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex17);
assertSame(complex16, complex4);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex9);
assertSame(complex16, complex6);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex20);
assertSame(complex16, complex10);
assertNotSame(complex16, complex8);
assertSame(complex16, complex5);
assertSame(complex16, complex14);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex19);
assertNotSame(complex4, complex20);
assertNotSame(complex4, complex0);
assertSame(complex4, complex16);
assertSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertSame(complex4, complex10);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex2);
assertSame(complex4, complex12);
assertSame(complex4, complex21);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex9);
assertSame(complex4, complex14);
assertNotSame(complex4, complex11);
assertSame(complex4, complex6);
assertSame(complex4, complex7);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex13);
assertSame(complex5, complex4);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex9);
assertSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex20);
assertSame(complex5, complex12);
assertSame(complex5, complex21);
assertNotSame(complex5, complex18);
assertSame(complex5, complex10);
Complex complex22 = complex20.subtract(6.123043201800016E-6);
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex7));
assertTrue(complex19.equals((Object)complex20));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex21));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex8));
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex6));
assertNotNull(complex22);
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(-0.0, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(0.0, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertFalse(complex22.isInfinite());
assertEquals((-6.123043201800016E-6), complex22.getReal(), 0.01);
assertEquals(-0.0, complex22.getImaginary(), 0.01);
assertFalse(complex22.isNaN());
}
@Test(timeout = 4000)
public void test045() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.sqrt1z();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.asin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.atan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.I.exp();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex3.INF.negate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertTrue(complex5.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertNotNull(complexField0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
ComplexField complexField1 = complex4.ZERO.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertNotNull(complexField1);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertSame(complexField1, complexField0);
Complex complex6 = complex2.INF.divide(complex3);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertTrue(complex6.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
Complex complex7 = complex0.subtract(complex2);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
Complex complex8 = complex4.divide(complex0);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertNotNull(complex8);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals((-0.5403023058681398), complex8.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
Complex complex9 = complex7.tanh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-1.0333696651172133), complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0813630257280234, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
Complex complex10 = complex7.cosh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex10);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(1.355714917853659, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-1.9364762536618505), complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
complex10.INF.hashCode();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(1.355714917853659, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-1.9364762536618505), complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
double double0 = complex10.I.abs();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertEquals(1.0, double0, 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(1.355714917853659, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-1.9364762536618505), complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
ComplexField complexField2 = complex0.NaN.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertNotNull(complexField2);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertSame(complexField2, complexField0);
assertSame(complexField2, complexField1);
Complex complex11 = complex10.NaN.divide(complex7);
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex11);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(1.355714917853659, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-1.9364762536618505), complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
Complex complex12 = complex11.I.log();
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex12);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(1.5707963267948966, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(1.355714917853659, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals((-1.9364762536618505), complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex10);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex0);
boolean boolean0 = complex2.isInfinite();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(boolean0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
ComplexField complexField3 = complex2.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertNotNull(complexField3);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertSame(complexField3, complexField0);
assertSame(complexField3, complexField2);
assertSame(complexField3, complexField1);
Complex complex13 = complex4.log();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex5));
assertNotNull(complex13);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertEquals(1.0, complex13.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex4);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex13);
Complex complex14 = complex7.tanh();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex11));
assertTrue(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertNotNull(complex14);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-1.0333696651172133), complex14.getReal(), 0.01);
assertEquals(0.0813630257280234, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(1.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals((-1.5707963267948966), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex4);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex9);
Complex complex15 = complex8.tan();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex14));
assertNotNull(complex15);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals((-0.8514190944727165), complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertEquals(0.6490586262393073, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex8.isInfinite());
assertEquals((-0.5403023058681398), complex8.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex13);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex14);
}
@Test(timeout = 4000)
public void test046() throws Throwable {
Complex complex0 = Complex.valueOf((-20.0), 0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = Complex.NaN;
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertNotSame(complex1, complex0);
Complex complex2 = Complex.ZERO;
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.tanh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-1.0), complex3.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.cosh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-1.0), complex3.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.5430806348152437, complex4.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
complex1.hashCode();
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
double double0 = complex3.abs();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertEquals(1.0, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-1.0), complex3.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
ComplexField complexField0 = complex4.getField();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-1.0), complex3.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.5430806348152437, complex4.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
Complex complex5 = complex4.divide(complex1);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-1.0), complex3.getReal(), 0.01);
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.5430806348152437, complex4.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertSame(complex5, complex1);
assertNotSame(complex5, complex0);
Complex complex6 = new Complex(2.3609400272358744E-8);
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(2.3609400272358744E-8, complex6.getReal(), 0.01);
Complex complex7 = complex6.log();
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertNotNull(complex7);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(2.3609400272358744E-8, complex6.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals((-17.561620887596483), complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
boolean boolean0 = complex3.isInfinite();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-1.0), complex3.getReal(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
ComplexField complexField1 = complex7.getField();
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertNotNull(complexField1);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(2.3609400272358744E-8, complex6.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals((-17.561620887596483), complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertSame(complexField1, complexField0);
Complex complex8 = complex2.log();
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex1));
assertNotNull(complex8);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertTrue(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex1);
Complex complex9 = complex0.tanh();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex6));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-1.0), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
}
@Test(timeout = 4000)
public void test047() throws Throwable {
Complex complex0 = new Complex((-1728.66484955));
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
Complex complex1 = complex0.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.createComplex(0, 797.126739284144);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.NaN.acos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
ComplexField complexField0 = complex2.INF.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
Complex complex5 = complex2.I.multiply(0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
Complex complex6 = complex5.INF.multiply(0);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertTrue(complex6.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
String string0 = complex2.toString();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertEquals("(-1.0070083253749793, 0.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
Complex complex7 = complex6.add(complex5);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex7.getImaginary(), 0.01);
assertTrue(complex7.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex7.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
Complex complex8 = complex5.log();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getReal(), 0.01);
assertTrue(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex5);
Complex complex9 = complex2.multiply(complex7);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex7.getImaginary(), 0.01);
assertTrue(complex7.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex7.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertTrue(complex9.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
Complex complex10 = Complex.ONE;
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex10);
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(1.0, complex10.getReal(), 0.01);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
Complex complex11 = Complex.valueOf(0.05170786544505468);
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertEquals(0.05170786544505468, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
Complex complex12 = complex10.add(complex11);
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex6));
assertNotNull(complex12);
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.05170786544505468, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(1.0517078654450547, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex10);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex6);
Complex complex13 = Complex.ZERO;
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertNotNull(complex13);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex8);
Complex complex14 = complex13.subtract(complex3);
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertNotNull(complex14);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals((-797.126739284144), complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex13);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex8);
double double0 = complex2.getImaginary();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
Complex complex15 = Complex.NaN;
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertNotNull(complex15);
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertTrue(complex15.isNaN());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex1);
assertSame(complex15, complex4);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
Complex complex16 = (Complex)complex2.readResolve();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex11));
assertTrue(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex1));
assertNotNull(complex16);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex16.isInfinite());
assertEquals((-1.0070083253749793), complex16.getReal(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex1);
boolean boolean0 = complex14.equals(complex16);
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertTrue(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex11));
assertTrue(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex16));
assertFalse(boolean0);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals((-797.126739284144), complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex16.isInfinite());
assertEquals((-1.0070083253749793), complex16.getReal(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex1);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex15);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex16);
Complex complex17 = complex2.sinh();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertTrue(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex12));
assertNotNull(complex17);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertFalse(complex17.isInfinite());
assertEquals((-1.1860445544165652), complex17.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex12);
Complex complex18 = complex10.asin();
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex18);
assertEquals(1.5707963267948966, complex18.getReal(), 0.01);
assertEquals(-0.0, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(1.0, complex10.getReal(), 0.01);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex12);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
Complex complex19 = complex18.createComplex(0.05170786544505468, (-2912.0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex19);
assertEquals(1.5707963267948966, complex18.getReal(), 0.01);
assertEquals(-0.0, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals((-2912.0), complex19.getImaginary(), 0.01);
assertEquals(0.05170786544505468, complex19.getReal(), 0.01);
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(1.0, complex10.getReal(), 0.01);
assertNotSame(complex18, complex19);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex12);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
Complex complex20 = complex14.conjugate();
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex19));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex17));
assertTrue(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertNotNull(complex20);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals((-797.126739284144), complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex20.isNaN());
assertFalse(complex20.isInfinite());
assertEquals(0.0, complex20.getReal(), 0.01);
assertEquals(797.126739284144, complex20.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex20);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex19);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex20);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex20);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex19);
assertNotSame(complex3, complex15);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex4);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex19);
assertNotSame(complex13, complex19);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex20);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex18);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex17);
Complex complex21 = complex20.INF.atan();
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex20));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex19));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex5));
assertTrue(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex17));
assertTrue(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertNotNull(complex21);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals((-797.126739284144), complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex20.isNaN());
assertFalse(complex20.isInfinite());
assertEquals(0.0, complex20.getReal(), 0.01);
assertEquals(797.126739284144, complex20.getImaginary(), 0.01);
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertTrue(complex21.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex20);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex21);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex19);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex20);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex20);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex21);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex19);
assertNotSame(complex3, complex15);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex4);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex21);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex19);
assertNotSame(complex21, complex0);
assertNotSame(complex21, complex20);
assertNotSame(complex21, complex1);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex14);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex7);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex19);
assertSame(complex21, complex4);
assertNotSame(complex21, complex3);
assertNotSame(complex21, complex6);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex10);
assertSame(complex21, complex15);
assertNotSame(complex13, complex19);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex20);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex18);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex21);
assertNotSame(complex13, complex17);
String string1 = complex11.toString();
assertFalse(string1.equals((Object)string0));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex20));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex21));
assertFalse(complex11.equals((Object)complex18));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex19));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex10));
assertEquals("(0.05170786544505468, 0.0)", string1);
assertNotNull(string1);
assertEquals(0.05170786544505468, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex20);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex21);
assertNotSame(complex11, complex18);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex17);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex19);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex10);
Complex complex22 = complex12.pow(complex10);
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex2));
assertTrue(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex21));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex20));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex20));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex21));
assertFalse(complex11.equals((Object)complex18));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex19));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex21));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex1));
assertNotNull(complex22);
assertEquals(0.0, complex22.getImaginary(), 0.01);
assertFalse(complex22.isNaN());
assertFalse(complex22.isInfinite());
assertEquals(1.0517078654450547, complex22.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.05170786544505468, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(1.0517078654450547, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex22, complex6);
assertNotSame(complex22, complex9);
assertNotSame(complex22, complex10);
assertNotSame(complex22, complex8);
assertNotSame(complex22, complex2);
assertNotSame(complex22, complex21);
assertNotSame(complex22, complex5);
assertNotSame(complex22, complex0);
assertNotSame(complex22, complex4);
assertNotSame(complex22, complex17);
assertNotSame(complex22, complex3);
assertNotSame(complex22, complex14);
assertNotSame(complex22, complex19);
assertNotSame(complex22, complex15);
assertNotSame(complex22, complex16);
assertNotSame(complex22, complex13);
assertNotSame(complex22, complex18);
assertNotSame(complex22, complex7);
assertNotSame(complex22, complex12);
assertNotSame(complex22, complex11);
assertNotSame(complex22, complex1);
assertNotSame(complex22, complex20);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex22);
assertNotSame(complex10, complex21);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex20);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex20);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex21);
assertNotSame(complex11, complex18);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex22);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex17);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex19);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex10);
double double1 = complex0.abs();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex20));
assertNotEquals(double1, double0, 0.01);
assertEquals(1728.66484955, double1, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
Complex complex23 = complex5.subtract(0.05170786544505468);
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex22));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex21));
assertFalse(complex2.equals((Object)complex8));
assertTrue(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex20));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex22));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex21));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex11));
assertNotNull(complex23);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex23.isInfinite());
assertFalse(complex23.isNaN());
assertEquals(0.0, complex23.getImaginary(), 0.01);
assertEquals((-0.05170786544505468), complex23.getReal(), 0.01);
Complex complex24 = complex13.sinh();
assertFalse(complex24.equals((Object)complex12));
assertTrue(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex10));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex11));
assertTrue(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex7));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex2));
assertFalse(complex24.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex23));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex22));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex21));
assertFalse(complex13.equals((Object)complex17));
assertNotNull(complex24);
assertFalse(complex24.isInfinite());
assertFalse(complex24.isNaN());
assertEquals(0.0, complex24.getReal(), 0.01);
assertEquals(0.0, complex24.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
}
@Test(timeout = 4000)
public void test048() throws Throwable {
Complex complex0 = new Complex((-1728.66484955));
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
Complex complex1 = complex0.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
ComplexField complexField0 = complex2.INF.getField();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
String string0 = complex2.toString();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertEquals("(-1.0070083253749793, 0.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
double double0 = complex1.getReal();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertEquals((-1.5707963267948966), double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
boolean boolean0 = complex2.isInfinite();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = new Complex((-2025.1947584));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex3.isInfinite());
assertEquals((-2025.1947584), complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
Complex complex4 = Complex.I;
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getReal(), 0.01);
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
Complex complex5 = (Complex)complex4.readResolve();
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getReal(), 0.01);
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(1.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
List<Complex> list0 = complex1.nthRoot(123);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertNotNull(list0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(list0.isEmpty());
assertEquals(123, list0.size());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertFalse(list0.contains(complex4));
boolean boolean1 = complex1.isInfinite();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
}
@Test(timeout = 4000)
public void test049() throws Throwable {
Complex complex0 = Complex.valueOf((-20.0), 0.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = (Complex)complex0.readResolve();
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
boolean boolean0 = complex1.equals(complex0);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertTrue(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.cosh();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.reciprocal();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(4.122307244877116E-9, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex1.tan();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals((-2.2371609442247427), complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
Complex complex5 = complex2.cos();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals((-0.9788301775225384), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
Complex complex6 = complex1.conjugate();
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertEquals((-20.0), complex6.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
Complex complex7 = (Complex)complex5.readResolve();
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals((-0.9788301775225384), complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertEquals((-0.9788301775225384), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
Complex complex8 = complex2.reciprocal();
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(4.122307244877116E-9, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
String string0 = complex6.toString();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex0));
assertEquals("(-20.0, -0.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertEquals((-20.0), complex6.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
Complex complex9 = Complex.I;
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
Complex complex10 = complex9.add(complex0);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-20.0), complex10.getReal(), 0.01);
assertEquals(1.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
Complex complex11 = complex9.conjugate();
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals((-1.0), complex11.getImaginary(), 0.01);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
Complex complex12 = complex2.asin();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertNotNull(complex12);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals((-20.0), complex12.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex12.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
Complex complex13 = Complex.ZERO;
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex6));
assertNotNull(complex13);
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex6);
boolean boolean1 = complex13.equals(complex2);
assertFalse(boolean1 == boolean0);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex6));
assertFalse(boolean1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(2.4258259770489514E8, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex6);
Complex complex14 = complex11.exp();
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex14);
assertFalse(complex14.isNaN());
assertEquals((-0.8414709848078965), complex14.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals((-1.0), complex11.getImaginary(), 0.01);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex13);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
}
@Test(timeout = 4000)
public void test050() throws Throwable {
Complex complex0 = Complex.valueOf((-2438.256513));
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.multiply((-2438.256513));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex1.NaN.pow(complex0);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex4.NaN.negate();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex5, complex1);
assertSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
Complex complex6 = complex1.sqrt1z();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
Complex complex7 = Complex.NaN;
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertSame(complex7, complex4);
assertNotSame(complex7, complex2);
Complex complex8 = complex1.NaN.add(complex7);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertTrue(complex8.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertSame(complex7, complex4);
assertSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertSame(complex8, complex7);
assertSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertSame(complex8, complex4);
Complex complex9 = complex6.ZERO.log();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertTrue(complex9.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
Complex complex10 = complex6.I.add(complex3);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex8));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(5945094.823186918, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex8);
Complex complex11 = complex1.subtract(complex3);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex11.isNaN());
assertEquals((-5945091.681594265), complex11.getReal(), 0.01);
assertEquals((-8.492185657535124), complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex4);
double double0 = complex9.getImaginary();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertTrue(complex9.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
Complex complex12 = Complex.NaN;
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertNotNull(complex12);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertSame(complex12, complex5);
assertSame(complex12, complex7);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertSame(complex12, complex8);
assertSame(complex12, complex4);
boolean boolean0 = complex4.equals(complex12);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertTrue(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex4, complex10);
assertSame(complex4, complex12);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex11);
assertSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertSame(complex4, complex7);
assertSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex6);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertSame(complex12, complex5);
assertSame(complex12, complex7);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertSame(complex12, complex8);
assertSame(complex12, complex4);
Complex complex13 = complex2.sinh();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex8));
assertNotNull(complex13);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(0.005525782205542805, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(1.1768576043096548, complex13.getReal(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex6);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex8);
Complex complex14 = complex6.asin();
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex9));
assertNotNull(complex14);
assertEquals(2.898739386328194, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(1.218440655622155, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
Complex complex15 = complex0.createComplex(406.429142882207, (-3116.186304));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex10));
assertNotNull(complex15);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertEquals(406.429142882207, complex15.getReal(), 0.01);
assertEquals((-3116.186304), complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex10);
Complex complex16 = complex6.conjugate();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex15));
assertNotNull(complex16);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(8.543893522980179, complex16.getReal(), 0.01);
assertEquals((-3.1225796532781587), complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex6);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex15);
String string0 = complex3.toString();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertEquals("(5945094.823186918, -0.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
Complex complex17 = complex11.sin();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex12));
assertNotNull(complex17);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(332.0188138525614, complex17.getImaginary(), 0.01);
assertEquals(2415.545137622649, complex17.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals((-5945091.681594265), complex11.getReal(), 0.01);
assertEquals((-8.492185657535124), complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex14);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex17);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex12);
Complex complex18 = complex6.multiply(280);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex17));
assertNotNull(complex18);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(2392.29018643445, complex18.getReal(), 0.01);
assertEquals(874.3223029178844, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex6);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex18);
assertNotSame(complex6, complex17);
}
@Test(timeout = 4000)
public void test051() throws Throwable {
Complex complex0 = Complex.valueOf((-20.0), 0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = Complex.valueOf((-1668.657));
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertNotSame(complex1, complex0);
Complex complex2 = complex0.subtract(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1648.657, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.ZERO.subtract((-36.077345753));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(36.077345753, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = Complex.I;
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
Complex complex5 = complex1.divide(complex4);
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertFalse(complex5.isInfinite());
assertEquals(0.0, complex5.getReal(), 0.01);
assertEquals(1668.657, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
Complex complex6 = complex1.tanh();
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
Complex complex7 = complex6.cosh();
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(1.5430806348152437, complex7.getReal(), 0.01);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
complex5.hashCode();
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertFalse(complex5.isInfinite());
assertEquals(0.0, complex5.getReal(), 0.01);
assertEquals(1668.657, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
double double0 = complex4.abs();
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertEquals(1.0, double0, 0.01);
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
ComplexField complexField0 = complex4.getField();
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertNotNull(complexField0);
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
Complex complex8 = complex0.divide(complex6);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(20.0, complex8.getReal(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
Complex complex9 = complex4.log();
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals(1.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(0.0, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(1.5707963267948966, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
boolean boolean0 = complex8.isInfinite();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(20.0, complex8.getReal(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
ComplexField complexField1 = complex1.getField();
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complexField1);
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertSame(complexField1, complexField0);
Complex complex10 = Complex.NaN;
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex8));
assertNotNull(complex10);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex8);
Complex complex11 = complex10.log();
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex8));
assertNotNull(complex11);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertSame(complex11, complex10);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertSame(complex10, complex11);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex8);
Complex complex12 = complex2.tanh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(1.0, complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertEquals((-1668.657), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1648.657, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
}
@Test(timeout = 4000)
public void test052() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.ZERO.exp();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.multiply(2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.NaN.createComplex((-2335.91542), 2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
Complex complex4 = complex1.multiply(1535521714);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
String string0 = complex1.toString();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertEquals("(1.0, 0.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
double double0 = complex2.getReal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertEquals(2.9850404523368767E-171, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
boolean boolean0 = complex3.isInfinite();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(boolean0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
Complex complex5 = complex1.multiply(1339);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1339.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
Complex complex6 = complex4.sqrt();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(39185.7335518936, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
Complex complex7 = (Complex)complex4.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(1.535521714E9, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
Complex complex8 = complex6.multiply((double) 1535521714);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(39185.7335518936, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(6.017054474795097E13, complex8.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
Complex complex9 = complex6.cos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(39185.7335518936, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals((-0.7970609403141397), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
complex2.hashCode();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
Complex complex10 = complex6.cos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertTrue(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertNotNull(complex10);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(39185.7335518936, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals((-0.7970609403141397), complex10.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
double double1 = complex9.abs();
assertNotEquals(double1, double0, 0.01);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertEquals(0.7970609403141397, double1, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(39185.7335518936, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals((-0.7970609403141397), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
Complex complex11 = complex5.tanh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertNotNull(complex11);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1339.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
Complex complex12 = Complex.ZERO;
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertNotNull(complex12);
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex2);
assertSame(complex12, complex0);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
Complex complex13 = complex12.conjugate();
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertTrue(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex3));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertNotNull(complex13);
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertSame(complex12, complex0);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex1);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
double double2 = complex2.getReal();
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertNotEquals(double2, double1, 0.01);
assertEquals(double2, double0, 0.01);
assertEquals(2.9850404523368767E-171, double2, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
Complex complex14 = complex4.multiply(complex11);
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex13));
assertTrue(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex12));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex1));
assertNotNull(complex14);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(1339.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex13);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex1);
Complex complex15 = Complex.I;
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex8));
assertNotNull(complex15);
assertFalse(complex15.isNaN());
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex8);
Complex complex16 = complex14.subtract(complex13);
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex13));
assertTrue(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex9));
assertTrue(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertTrue(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex12));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex12));
assertTrue(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex15));
assertTrue(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex1));
assertNotNull(complex16);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertEquals(1.535521714E9, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(1339.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex8);
assertSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex5);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex16);
assertNotSame(complex12, complex2);
assertSame(complex12, complex0);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex1);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex13);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex7);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex1);
Complex complex17 = Complex.ONE;
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex15));
assertTrue(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex3));
assertTrue(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex4));
assertNotNull(complex17);
assertEquals(1.0, complex17.getReal(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex4);
Complex complex18 = complex17.divide(complex1);
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex15));
assertTrue(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex3));
assertTrue(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex15));
assertTrue(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex12));
assertTrue(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex4));
assertTrue(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex6));
assertNotNull(complex18);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex17.getReal(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(1.0, complex18.getReal(), 0.01);
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertFalse(complex18.isNaN());
assertFalse(complex18.isInfinite());
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex8);
assertSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex18);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex4);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex6);
Complex complex19 = complex0.cosh();
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex12));
assertTrue(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex15));
assertTrue(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex5));
assertTrue(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex13));
assertNotNull(complex19);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(1.0, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex8);
assertSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex15);
Complex complex20 = (Complex)complex11.readResolve();
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex8));
assertTrue(complex11.equals((Object)complex18));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex13));
assertTrue(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertTrue(complex11.equals((Object)complex19));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex15));
assertTrue(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex12));
assertTrue(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex8));
assertTrue(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex2));
assertTrue(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex13));
assertNotNull(complex20);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1339.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertFalse(complex20.isNaN());
assertFalse(complex20.isInfinite());
assertEquals(1.0, complex20.getReal(), 0.01);
assertEquals(0.0, complex20.getImaginary(), 0.01);
Complex complex21 = complex15.asin();
assertFalse(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex20));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex0));
assertNotNull(complex21);
assertFalse(complex15.isNaN());
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
assertEquals(0.8813735870195428, complex21.getImaginary(), 0.01);
assertEquals(0.0, complex21.getReal(), 0.01);
Complex complex22 = complex8.acos();
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex21));
assertTrue(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertTrue(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex6));
assertTrue(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex18));
assertFalse(complex6.equals((Object)complex21));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex20));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex19));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex18));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex21));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex19));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex20));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex13));
assertNotNull(complex22);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.535521714E9, complex4.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(39185.7335518936, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(6.017054474795097E13, complex8.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex22.getReal(), 0.01);
assertFalse(complex22.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex22.getImaginary(), 0.01);
assertTrue(complex22.isInfinite());
complex21.hashCode();
assertFalse(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex21));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex20));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex22));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex22));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex15.isNaN());
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(1.0, complex15.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
assertEquals(0.8813735870195428, complex21.getImaginary(), 0.01);
assertEquals(0.0, complex21.getReal(), 0.01);
Complex complex23 = complex13.sqrt1z();
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex17));
assertTrue(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex22));
assertFalse(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex21));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertTrue(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex21));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex22));
assertFalse(complex13.equals((Object)complex14));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex20));
assertTrue(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex15));
assertTrue(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex13));
assertTrue(complex23.equals((Object)complex20));
assertTrue(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex3));
assertTrue(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex22));
assertTrue(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex12));
assertNotNull(complex23);
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getReal(), 0.01);
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(1.0, complex23.getReal(), 0.01);
assertFalse(complex23.isInfinite());
assertFalse(complex23.isNaN());
assertEquals(0.0, complex23.getImaginary(), 0.01);
Complex complex24 = complex0.cosh();
assertFalse(complex24.equals((Object)complex2));
assertTrue(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex9));
assertTrue(complex24.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex7));
assertTrue(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex0));
assertTrue(complex24.equals((Object)complex11));
assertFalse(complex24.equals((Object)complex10));
assertTrue(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex12));
assertTrue(complex24.equals((Object)complex17));
assertTrue(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex22));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertNotNull(complex24);
assertEquals(1.0, complex24.getReal(), 0.01);
assertFalse(complex24.isNaN());
assertEquals(0.0, complex24.getImaginary(), 0.01);
assertFalse(complex24.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
}
@Test(timeout = 4000)
public void test053() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.sqrt1z();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.asin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.atan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex3.I.exp();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
Complex complex5 = complex3.INF.negate();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
ComplexField complexField1 = complex4.ZERO.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complexField1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertSame(complexField1, complexField0);
Complex complex6 = complex2.subtract(complex4);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(1.0304940209267568, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-0.8414709848078965), complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
Complex complex7 = complex5.divide(complex4);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex7.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
Complex complex8 = complex3.tanh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.7421805438718688, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals((-4.9867670026466293E-17), complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
Complex complex9 = complex4.cosh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.42275158565596294, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.7660211626054872, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
complex1.hashCode();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
double double0 = complex7.abs();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex8));
assertEquals(Double.NaN, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex7.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex8);
ComplexField complexField2 = complex6.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complexField2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(1.0304940209267568, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-0.8414709848078965), complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertSame(complexField2, complexField0);
assertSame(complexField2, complexField1);
Complex complex10 = complex9.divide(complex2);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.42275158565596294, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.7660211626054872, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(0.48766421816665534, complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(0.2691320182283332, complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
Complex complex11 = complex8.log();
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex11);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals((-0.2981627448303749), complex11.getReal(), 0.01);
assertEquals((-6.719075356827937E-17), complex11.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.7421805438718688, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals((-4.9867670026466293E-17), complex8.getImaginary(), 0.01);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex11);
boolean boolean0 = complex0.isInfinite();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
ComplexField complexField3 = complex11.getField();
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex11));
assertNotNull(complexField3);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals((-0.2981627448303749), complex11.getReal(), 0.01);
assertEquals((-6.719075356827937E-17), complex11.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.7421805438718688, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals((-4.9867670026466293E-17), complex8.getImaginary(), 0.01);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertSame(complexField3, complexField1);
assertSame(complexField3, complexField2);
assertSame(complexField3, complexField0);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex11);
Complex complex12 = complex5.log();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertEquals((-2.356194490192345), complex12.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
Complex complex13 = complex4.tanh();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.8514190944727165, complex13.getReal(), 0.01);
assertEquals(0.6490586262393073, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex3);
}
@Test(timeout = 4000)
public void test054() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.sqrt1z();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.asin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex1.atan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex3.I.exp();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
Complex complex5 = complex3.INF.negate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertNotNull(complexField0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
ComplexField complexField1 = complex4.ZERO.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complexField1);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertSame(complexField1, complexField0);
Complex complex6 = complex2.subtract(complex5);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertTrue(complex6.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
Complex complex7 = complex1.divide(complex4);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex7.isInfinite());
assertEquals((-1.1900196790587718), complex7.getImaginary(), 0.01);
assertEquals(0.7641028487401795, complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
Complex complex8 = complex4.tanh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex8.isNaN());
assertEquals(0.6490586262393073, complex8.getImaginary(), 0.01);
assertEquals(0.8514190944727165, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex5);
Complex complex9 = complex2.cosh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex9);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertEquals(2.5091784786580567, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
complex6.hashCode();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertTrue(complex6.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
double double0 = complex5.abs();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertEquals(Double.POSITIVE_INFINITY, double0, 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
ComplexField complexField2 = complex2.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertNotNull(complexField2);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertSame(complexField2, complexField0);
assertSame(complexField2, complexField1);
Complex complex10 = complex0.divide(complex3);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex10);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(1.0467733744265997, complex10.getImaginary(), 0.01);
assertEquals((-1.2165096678989356E-16), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
Complex complex11 = complex9.log();
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex10));
assertNotNull(complex11);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.9199554002301539, complex11.getReal(), 0.01);
assertEquals(-0.0, complex11.getImaginary(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertEquals(2.5091784786580567, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
boolean boolean0 = complex9.isInfinite();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex10));
assertFalse(boolean0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertEquals(2.5091784786580567, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
ComplexField complexField3 = complex3.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complexField3);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertSame(complexField3, complexField1);
assertSame(complexField3, complexField0);
assertSame(complexField3, complexField2);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
Complex complex12 = complex3.log();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex12);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals((-0.045712456144603224), complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals((-1.162151901852981E-16), complex12.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex4);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
Complex complex13 = complex1.tanh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex4));
assertNotNull(complex13);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(0.8883855615856606, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex4);
}
@Test(timeout = 4000)
public void test055() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.sqrt1z();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.asin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex1.atan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.I.exp();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
Complex complex5 = complex3.INF.negate();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertNotNull(complexField0);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
ComplexField complexField1 = complex4.ZERO.getField();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complexField1);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertSame(complexField1, complexField0);
Complex complex6 = complex4.divide(complex0);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-0.5403023058681398), complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.8414709848078965, complex6.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
Complex complex7 = complex1.tanh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertNotNull(complex7);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(0.8883855615856606, complex7.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
Complex complex8 = complex2.cosh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex8);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(2.5091784786580567, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
complex8.INF.hashCode();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(2.5091784786580567, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
double double0 = complex8.I.abs();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertEquals(1.0, double0, 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(2.5091784786580567, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
Complex complex9 = (Complex)complex6.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-0.5403023058681398), complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.8414709848078965, complex6.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(0.8414709848078965, complex9.getReal(), 0.01);
assertEquals((-0.5403023058681398), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
Complex complex10 = complex8.INF.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertNotNull(complex10);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(2.5091784786580567, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
Complex complex11 = complex4.reciprocal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertNotNull(complex11);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-0.8414709848078965), complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.5403023058681398, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex11);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
String string0 = complex5.toString();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertEquals("(-Infinity, -Infinity)", string0);
assertNotNull(string0);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
Complex complex12 = complex6.add(complex1);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex12);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-0.5403023058681398), complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(2.2556845471809917, complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-0.5403023058681398), complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.8414709848078965, complex6.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex11);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
Complex complex13 = complex12.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex13);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-0.5403023058681398), complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(2.2556845471809917, complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(2.2556845471809917, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(0.5403023058681398, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-0.5403023058681398), complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.8414709848078965, complex6.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex9);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
Complex complex14 = Complex.INF;
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex8));
assertNotNull(complex14);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertTrue(complex14.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex8);
Complex complex15 = complex14.asin();
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex5));
assertNotNull(complex15);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertTrue(complex14.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertTrue(complex15.isNaN());
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex5);
boolean boolean0 = complex14.equals(complexField1);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex9));
assertFalse(boolean0);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertTrue(complex14.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex8);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex9);
assertSame(complexField1, complexField0);
Complex complex16 = complex8.exp();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex16);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex16.isNaN());
assertEquals(12.294825448999884, complex16.getReal(), 0.01);
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex8.isInfinite());
assertEquals(2.5091784786580567, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex14);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex6);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex4);
}
@Test(timeout = 4000)
public void test056() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.ZERO.exp();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.multiply(2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.NaN.createComplex((-2335.91542), 2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
Complex complex4 = complex0.add(2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(2.9850404523368767E-171, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
Complex complex5 = complex2.acos();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
Complex complex6 = complex2.sqrt1z();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
Complex complex7 = complex6.ONE.add(complex5);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(2.5707963267948966, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
Complex complex8 = (Complex)complex5.readResolve();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
Complex complex9 = complex3.sinh();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex9.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex1);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
boolean boolean0 = complex7.equals(complex8);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex9));
assertTrue(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(2.5707963267948966, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
double double0 = complex1.getArgument();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
Complex complex10 = (Complex)complex7.readResolve();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex5));
assertTrue(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(2.5707963267948966, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(2.5707963267948966, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex10);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
try {
complex8.nthRoot((-67988804));
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: -67,988,804
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test057() throws Throwable {
Complex complex0 = new Complex((-1728.66484955));
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
Complex complex1 = complex0.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.createComplex(0, 797.126739284144);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
ComplexField complexField0 = complex2.INF.getField();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex4 = complex1.INF.multiply(0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertTrue(complex4.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
String string0 = complex2.toString();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertEquals("(-1.0070083253749793, 0.0)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
double double0 = complex1.getReal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertEquals((-1.5707963267948966), double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
boolean boolean0 = complex2.isInfinite();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex5 = complex1.multiply(363);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
Complex complex6 = complex5.sqrt();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(42.323006453151486, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(34.94335142207963, complex6.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
Complex complex7 = (Complex)complex2.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex7.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
Complex complex8 = complex3.NaN.multiply((-1.5707963267948966));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex6);
Complex complex9 = complex8.ZERO.cos();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex9);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex0);
complex6.hashCode();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(42.323006453151486, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(34.94335142207963, complex6.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
Complex complex10 = complex5.cos();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
double double1 = complex10.NaN.abs();
assertNotEquals(double1, double0, 0.01);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertEquals(Double.NaN, double1, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
Complex complex11 = complex0.NaN.tanh();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex11);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
Complex complex12 = complex2.conjugate();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex2));
assertTrue(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex9));
assertNotNull(complex12);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-1.0070083253749793), complex12.getReal(), 0.01);
assertEquals(-0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex9);
double double2 = complex10.getReal();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertNotEquals(double2, double1, 0.01);
assertNotEquals(double2, double0, 0.01);
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertEquals(Double.POSITIVE_INFINITY, double2, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
Complex complex13 = complex5.multiply(complex11);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex13);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertSame(complex11, complex13);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex13, complex7);
assertSame(complex13, complex11);
assertNotSame(complex13, complex9);
assertSame(complex13, complex8);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex11);
Complex complex14 = Complex.I;
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex2));
assertNotNull(complex14);
assertEquals(1.0, complex14.getImaginary(), 0.01);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex2);
Complex complex15 = complex13.ONE.subtract(complex14);
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex11));
assertNotNull(complex15);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertEquals(1.0, complex14.getImaginary(), 0.01);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(1.0, complex15.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertEquals((-1.0), complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertSame(complex11, complex13);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex13, complex7);
assertSame(complex13, complex11);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex15);
assertSame(complex13, complex8);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex15);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex0);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
Complex complex16 = complex0.divide(complex0);
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex7));
assertTrue(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex15));
assertNotNull(complex16);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertEquals(1.0, complex16.getReal(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex16.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex15);
Complex complex17 = complex10.cosh();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex16));
assertTrue(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex10));
assertTrue(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex2));
assertTrue(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex17);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertTrue(complex17.isNaN());
assertEquals(Double.NaN, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(Double.NaN, complex17.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex8);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
Complex complex18 = complex10.asin();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex16));
assertTrue(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex18);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex15);
assertSame(complex18, complex11);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex16);
assertSame(complex18, complex13);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex14);
assertSame(complex18, complex8);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex17);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
Complex complex19 = complex10.acos();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex2));
assertTrue(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex19);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertTrue(complex19.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
assertSame(complex19, complex8);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex16);
assertSame(complex19, complex13);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex6);
assertSame(complex19, complex11);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex4);
assertSame(complex19, complex18);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
complex5.hashCode();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
Complex complex20 = complex18.sqrt1z();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex16));
assertTrue(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex3));
assertTrue(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex20);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-570.1990666265475), complex5.getReal(), 0.01);
assertEquals(2957.815375462833, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertTrue(complex20.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertTrue(complex10.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex15);
assertSame(complex18, complex11);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex4);
assertSame(complex18, complex19);
assertNotSame(complex18, complex16);
assertSame(complex18, complex13);
assertNotSame(complex18, complex0);
assertSame(complex18, complex20);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex14);
assertSame(complex18, complex8);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex17);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex19);
Complex complex21 = complex1.cosh();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex11));
assertNotNull(complex21);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals((-0.7277656197032484), complex21.getReal(), 0.01);
assertEquals((-2.2023755015523196), complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
}
@Test(timeout = 4000)
public void test058() throws Throwable {
Complex complex0 = Complex.NaN;
assertNotNull(complex0);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = Complex.ZERO;
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertNotSame(complex1, complex0);
Complex complex2 = complex1.acos();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = Complex.ONE;
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(1.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = (Complex)complex1.readResolve();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
Complex complex5 = complex0.reciprocal();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertSame(complex5, complex0);
Complex complex6 = complex0.multiply((-2335.91542));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertSame(complex6, complex0);
assertSame(complex6, complex5);
assertNotSame(complex6, complex1);
Complex complex7 = complex5.cos();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertSame(complex0, complex5);
assertSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertSame(complex5, complex6);
assertSame(complex5, complex0);
assertSame(complex5, complex7);
assertSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertSame(complex7, complex5);
assertNotSame(complex7, complex1);
Complex complex8 = complex5.conjugate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertSame(complex0, complex5);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertSame(complex5, complex6);
assertSame(complex5, complex0);
assertSame(complex5, complex7);
assertNotSame(complex8, complex1);
assertSame(complex8, complex5);
assertSame(complex8, complex6);
assertSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertSame(complex8, complex0);
Complex complex9 = (Complex)complex5.readResolve();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex9.equals((Object)complex8));
assertTrue(complex9.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertTrue(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertSame(complex0, complex5);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex5, complex9);
assertSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertSame(complex5, complex6);
assertSame(complex5, complex0);
assertSame(complex5, complex7);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
Complex complex10 = complex2.asin();
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-1.0232274785475506), complex10.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex10.getReal(), 0.01);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex1);
Complex complex11 = complex7.exp();
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex10));
assertTrue(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertSame(complex5, complex11);
assertNotSame(complex5, complex9);
assertSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertSame(complex5, complex6);
assertSame(complex5, complex0);
assertSame(complex5, complex7);
assertNotSame(complex5, complex10);
assertNotSame(complex7, complex9);
assertSame(complex7, complex8);
assertSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertSame(complex11, complex7);
assertNotSame(complex11, complex2);
assertSame(complex11, complex0);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex9);
assertSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertSame(complex11, complex6);
assertSame(complex11, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex4);
}
@Test(timeout = 4000)
public void test059() throws Throwable {
Complex complex0 = Complex.valueOf((-20.0));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
Complex complex1 = complex0.log();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.divide((-6300.9646));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals((-4.7544026410717985E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-4.985891610293753E-4), complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.sin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals((-4.7544026410717985E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-4.985891610293753E-4), complex2.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-4.754403052906079E-4), complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals((-4.985891253354442E-4), complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = Complex.valueOf(2.0);
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
Complex complex5 = complex1.tan();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-0.0010703233329367858), complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(0.9964287244829098, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
Complex complex6 = complex0.tan();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals((-2.2371609442247427), complex6.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
Complex complex7 = complex0.multiply(complex4);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals((-40.0), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex7);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
complex5.hashCode();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-0.0010703233329367858), complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(0.9964287244829098, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
Complex complex8 = complex3.sqrt1z();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals((-4.7544026410717985E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-4.985891610293753E-4), complex2.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-4.754403052906079E-4), complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals((-4.985891253354442E-4), complex3.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(1.000000011273844, complex8.getReal(), 0.01);
assertEquals((-2.3704936329160318E-7), complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
boolean boolean0 = complex1.equals(complex5);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-0.0010703233329367858), complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(0.9964287244829098, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
Complex complex9 = complex5.negate();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-0.0010703233329367858), complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(0.9964287244829098, complex5.getImaginary(), 0.01);
assertEquals((-0.9964287244829098), complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.0010703233329367858, complex9.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
Complex complex10 = complex2.multiply((-6300.9646));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex9));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals((-4.7544026410717985E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-4.985891610293753E-4), complex2.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(3.1415926535897936, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(2.995732273553991, complex10.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex10);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex9);
Complex complex11 = complex0.add(complex7);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals((-40.0), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals((-60.0), complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex7);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex8);
Complex complex12 = (Complex)complex2.readResolve();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals((-4.7544026410717985E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-4.985891610293753E-4), complex2.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals((-4.7544026410717985E-4), complex12.getReal(), 0.01);
assertEquals((-4.985891610293753E-4), complex12.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex11);
Complex complex13 = complex3.conjugate();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex10));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(3.141592653589793, complex1.getImaginary(), 0.01);
assertEquals(2.995732273553991, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals((-4.7544026410717985E-4), complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-4.985891610293753E-4), complex2.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-4.754403052906079E-4), complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals((-4.985891253354442E-4), complex3.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals((-4.754403052906079E-4), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(4.985891253354442E-4, complex13.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex10);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex10);
Complex complex14 = (Complex)complex11.readResolve();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex3));
assertTrue(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex14);
assertEquals((-60.0), complex14.getReal(), 0.01);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals((-40.0), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals((-60.0), complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex7);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
Complex complex15 = complex7.reciprocal();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertNotNull(complex15);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals((-20.0), complex0.getReal(), 0.01);
assertEquals((-0.025), complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals((-40.0), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex6);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex4);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex7);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
}
@Test(timeout = 4000)
public void test060() throws Throwable {
Complex complex0 = new Complex(0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.INF.divide(3003.3359);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.add(complex0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex2.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.I.add(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex3.NaN.sqrt();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
Complex complex5 = complex0.ZERO.tan();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
double double0 = complex0.ZERO.abs();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertEquals(0.0, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
ComplexField complexField0 = complex5.INF.getField();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
Complex complex6 = Complex.valueOf(0.0, 0.0);
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
Complex complex7 = complex0.NaN.cosh();
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
Complex complex8 = complex0.ONE.cos();
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.5403023058681398, complex8.getReal(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
Complex complex9 = complex0.acos();
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(1.5707963267948966, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex7);
Complex complex10 = complex0.sqrt1z();
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
Complex complex11 = complex10.ZERO.divide(complex8);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertTrue(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertTrue(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.5403023058681398, complex8.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex10);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
Complex complex12 = complex3.INF.atan();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex8));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex11);
assertSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex8);
assertSame(complex12, complex7);
Complex complex13 = complex10.INF.add(complex4);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex2));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex13);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertSame(complex4, complex7);
assertNotSame(complex4, complex10);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex6);
assertSame(complex4, complex13);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
assertSame(complex13, complex12);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertSame(complex13, complex7);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex10);
assertSame(complex13, complex4);
Complex complex14 = complex0.atan();
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex1));
assertTrue(complex14.equals((Object)complex5));
assertTrue(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex3));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertNotNull(complex14);
assertEquals(0.0, complex14.getReal(), 0.01);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
Complex complex15 = complex14.INF.subtract(0.0);
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex1));
assertTrue(complex14.equals((Object)complex5));
assertTrue(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex3));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex12));
assertTrue(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex5));
assertTrue(complex15.equals((Object)complex3));
assertTrue(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex7));
assertNotNull(complex15);
assertEquals(0.0, complex14.getReal(), 0.01);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertTrue(complex15.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex15.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex15.getReal(), 0.01);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex7);
Complex complex16 = complex5.asin();
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex2));
assertTrue(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertTrue(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertTrue(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex14));
assertTrue(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex12));
assertTrue(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex15));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex14);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex15);
Complex complex17 = complex5.subtract((-1427.3465));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex12));
assertTrue(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex15));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(1427.3465, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex15);
double double1 = complex3.getArgument();
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex12));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex13));
assertNotEquals(double1, double0, 0.01);
assertEquals(0.7853981633974483, double1, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex13);
Complex complex18 = complex2.exp();
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex12));
assertTrue(complex2.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex8));
assertTrue(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex17));
assertTrue(complex18.equals((Object)complex13));
assertTrue(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex9));
assertTrue(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex0));
assertNotNull(complex18);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex2.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex0);
Complex complex19 = complex0.pow(complex16);
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex18));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex2));
assertTrue(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex12));
assertTrue(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertTrue(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex14));
assertTrue(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex18));
assertTrue(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex12));
assertTrue(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex17));
assertTrue(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex14));
assertTrue(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex1));
assertTrue(complex19.equals((Object)complex7));
assertTrue(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex6));
assertTrue(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex5));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertTrue(complex19.isNaN());
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex18);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex19);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex17);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex15);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex5);
Complex complex20 = complex4.tan();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex18));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex12));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex14));
assertTrue(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex16));
assertTrue(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex0));
assertNotNull(complex20);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertTrue(complex3.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex20.isNaN());
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex3, complex19);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex20);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex13);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex1);
assertSame(complex4, complex7);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex16);
assertSame(complex4, complex12);
assertNotSame(complex4, complex11);
assertSame(complex4, complex20);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex6);
assertSame(complex4, complex13);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex5);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex6);
assertSame(complex20, complex13);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex11);
assertSame(complex20, complex4);
assertSame(complex20, complex12);
assertSame(complex20, complex7);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex0);
Complex complex21 = complex11.createComplex((-92.3), 8.69177352065934E-9);
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex18));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex18));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex20));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex20));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex18));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex4));
assertTrue(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex19));
assertTrue(complex11.equals((Object)complex14));
assertTrue(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex9));
assertTrue(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex20));
assertNotNull(complex21);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex21.isNaN());
assertEquals((-92.3), complex21.getReal(), 0.01);
assertEquals(8.69177352065934E-9, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertFalse(complex8.isInfinite());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.5403023058681398, complex8.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex21, complex20);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex6);
assertNotSame(complex21, complex3);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex4);
assertNotSame(complex21, complex10);
assertNotSame(complex21, complex1);
assertNotSame(complex21, complex7);
assertNotSame(complex21, complex15);
assertNotSame(complex21, complex14);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex0);
assertNotSame(complex21, complex19);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex2);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex17);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex18);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex20);
assertNotSame(complex8, complex21);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex19);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex20);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex21);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
assertNotSame(complex11, complex18);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex21);
assertNotSame(complex11, complex17);
assertNotSame(complex11, complex19);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex20);
}
@Test(timeout = 4000)
public void test061() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.sqrt1z();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.asin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.atan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.I.exp();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
Complex complex5 = complex3.INF.negate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
ComplexField complexField1 = complex4.ZERO.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complexField1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertSame(complexField1, complexField0);
Complex complex6 = complex0.subtract(complex2);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
Complex complex7 = complex4.divide(complex0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(0.8414709848078965, complex7.getReal(), 0.01);
assertEquals((-0.5403023058681398), complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
Complex complex8 = complex6.tanh();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0813630257280234, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals((-1.0333696651172133), complex8.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
Complex complex9 = complex6.cosh();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex9.isInfinite());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
complex9.INF.hashCode();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex9.isInfinite());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
double double0 = complex9.I.abs();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertEquals(1.0, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex9.isInfinite());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
ComplexField complexField2 = complex0.NaN.getField();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertNotNull(complexField2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertSame(complexField2, complexField1);
assertSame(complexField2, complexField0);
Complex complex10 = complex9.NaN.divide(complex6);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertNotNull(complex10);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex9.isInfinite());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
Complex complex11 = complex10.I.log();
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertNotNull(complex11);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals(1.5707963267948966, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex9.isInfinite());
assertEquals(1.355714917853659, complex9.getReal(), 0.01);
assertEquals((-1.9364762536618505), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
boolean boolean0 = complex2.isInfinite();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(boolean0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
ComplexField complexField3 = complex2.getField();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertNotNull(complexField3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertSame(complexField3, complexField0);
assertSame(complexField3, complexField2);
assertSame(complexField3, complexField1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
Complex complex12 = complex4.log();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex10));
assertNotNull(complex12);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(1.0, complex12.getImaginary(), 0.01);
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.9553166181245093, complex3.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex3.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex4.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex10);
Complex complex13 = complex6.tanh();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex2));
assertTrue(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex13);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.4142135623730951, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0333696651172133), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(0.0813630257280234, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(1.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.5707963267948966), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex13);
}
@Test(timeout = 4000)
public void test062() throws Throwable {
Complex complex0 = new Complex(171.33822774395662, 171.33822774395662);
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.NaN.exp();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.INF.sinh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.I.subtract(171.33822774395662);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals((-171.33822774395662), complex3.getReal(), 0.01);
assertEquals(1.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex0.createComplex(0.0, 0.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
Complex complex5 = complex0.sin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertNotNull(complex5);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-1.5612352456880728E73), complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(1.2794024056327664E74, complex5.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
ComplexField complexField0 = complex5.I.getField();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertNotNull(complexField0);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-1.5612352456880728E73), complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertEquals(1.2794024056327664E74, complex5.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
Complex complex6 = complex0.I.pow((-2162.241882929934));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(0.37087293787891845, complex6.getImaginary(), 0.01);
assertEquals((-0.9286836188654669), complex6.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
Complex complex7 = Complex.valueOf(171.33822774395662, 0.0);
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertEquals(171.33822774395662, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
Complex complex8 = complex0.NaN.subtract(0.0);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex2));
assertNotNull(complex8);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertTrue(complex8.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertSame(complex8, complex1);
assertNotSame(complex8, complex5);
Complex complex9 = Complex.valueOf((-2162.241882929934), (-4335.4560186844));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertNotNull(complex9);
assertFalse(complex9.isInfinite());
assertEquals((-4335.4560186844), complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals((-2162.241882929934), complex9.getReal(), 0.01);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
boolean boolean0 = complex2.equals(complex4);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(boolean0);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertSame(complex1, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
double double0 = complex0.abs();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertEquals(242.30884542847357, double0, 0.01);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
boolean boolean1 = complex3.isInfinite();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals((-171.33822774395662), complex3.getReal(), 0.01);
assertEquals(1.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertSame(complex1, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex10 = complex0.sin();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex9));
assertTrue(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertFalse(complex0.isNaN());
assertEquals(171.33822774395662, complex0.getImaginary(), 0.01);
assertEquals(171.33822774395662, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-1.5612352456880728E73), complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(1.2794024056327664E74, complex10.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex5);
}
@Test(timeout = 4000)
public void test063() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.ONE.log();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.divide((-6300.9646));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.sin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = Complex.valueOf((-6300.9646));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
Complex complex5 = complex4.ZERO.tan();
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
Complex complex6 = complex1.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
Complex complex7 = complex6.I.multiply(complex5);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertTrue(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
complex6.INF.hashCode();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex3));
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
Complex complex8 = complex2.NaN.sqrt1z();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
boolean boolean0 = complex2.equals("{0} out of [{1}, {2}] range");
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(boolean0);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
Complex complex9 = complex2.negate();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertNotNull(complex9);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.5870585909973211E-4, complex9.getImaginary(), 0.01);
assertEquals(0.0, complex9.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
Complex complex10 = complex9.ZERO.multiply((-6300.9646));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertTrue(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex5));
assertTrue(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertTrue(complex10.equals((Object)complex6));
assertNotNull(complex10);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.5870585909973211E-4, complex9.getImaginary(), 0.01);
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertEquals(-0.0, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex2);
Complex complex11 = complex9.ZERO.add(complex4);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex2));
assertTrue(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex0));
assertNotNull(complex11);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-6300.9646), complex4.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.5870585909973211E-4, complex9.getImaginary(), 0.01);
assertEquals(0.0, complex9.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals((-6300.9646), complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex9);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex2);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex0);
Complex complex12 = (Complex)complex2.readResolve();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertTrue(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex10));
assertNotNull(complex12);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex12.isInfinite());
assertEquals((-1.5870585909973211E-4), complex12.getImaginary(), 0.01);
assertEquals(-0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex10);
Complex complex13 = complex9.conjugate();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex8));
assertTrue(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex9));
assertNotNull(complex13);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.5870585909973211E-4, complex9.getImaginary(), 0.01);
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals((-1.5870585909973211E-4), complex13.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex13);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex9);
Complex complex14 = (Complex)complex1.readResolve();
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex2));
assertTrue(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex8));
assertTrue(complex14.equals((Object)complex3));
assertTrue(complex14.equals((Object)complex5));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertNotNull(complex14);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(0.0, complex14.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
Complex complex15 = complex2.reciprocal();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex15);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertEquals(6300.9646, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertEquals((-1.5870585909973211E-4), complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(-0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex13);
}
@Test(timeout = 4000)
public void test064() throws Throwable {
Complex complex0 = Complex.valueOf((-20.0), 0.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
Complex complex1 = (Complex)complex0.readResolve();
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.ONE.sinh();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
boolean boolean0 = complex0.equals(complex1);
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertTrue(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals((-20.0), complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
double double0 = complex0.getArgument();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertEquals(3.141592653589793, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
Complex complex3 = (Complex)complex0.readResolve();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-20.0), complex0.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals((-20.0), complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
}
@Test(timeout = 4000)
public void test065() throws Throwable {
Complex complex0 = Complex.valueOf(2465.1876420644858, 2465.1876420644858);
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.ONE.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.conjugate();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2465.1876420644858), complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(2465.1876420644858, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.sqrt();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2465.1876420644858), complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(2465.1876420644858, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(54.550386979684355, complex3.getReal(), 0.01);
assertEquals((-22.595510119685958), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = Complex.valueOf(0.10026945173740387, 0.10026945173740387);
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertFalse(complex4.isInfinite());
assertEquals(0.10026945173740387, complex4.getImaginary(), 0.01);
assertEquals(0.10026945173740387, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
Complex complex5 = Complex.valueOf(0.0);
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
Complex complex6 = complex0.ONE.tanh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.7615941559557649, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
double double0 = complex3.getImaginary();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertEquals((-22.595510119685958), double0, 0.01);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2465.1876420644858), complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(2465.1876420644858, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(54.550386979684355, complex3.getReal(), 0.01);
assertEquals((-22.595510119685958), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
double double1 = complex0.getArgument();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertNotEquals(double1, double0, 0.01);
assertEquals(0.7853981633974483, double1, 0.01);
assertFalse(complex0.isNaN());
assertEquals(2465.1876420644858, complex0.getImaginary(), 0.01);
assertEquals(2465.1876420644858, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
}
@Test(timeout = 4000)
public void test066() throws Throwable {
Complex complex0 = Complex.INF;
assertNotNull(complex0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.tan();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = new Complex(0.0);
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
Complex complex3 = complex0.ZERO.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex1.subtract(complex2);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertSame(complex1, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex1);
double double0 = complex3.ONE.abs();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertEquals(1.0, double0, 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex5 = complex4.log();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertSame(complex1, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex1);
assertSame(complex4, complex5);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertSame(complex5, complex4);
assertSame(complex5, complex1);
assertNotSame(complex5, complex2);
Complex complex6 = complex2.multiply(complex3);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
complex6.ONE.hashCode();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
Complex complex7 = complex6.atan();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
Complex complex8 = complex3.NaN.sin();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertSame(complex8, complex5);
assertNotSame(complex8, complex7);
List<Complex> list0 = complex0.nthRoot(768);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertNotNull(list0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(list0.isEmpty());
assertEquals(1, list0.size());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertTrue(list0.contains(complex0));
assertFalse(list0.contains(complex1));
Complex complex9 = complex2.pow(complex3);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex8));
assertTrue(complex9.equals((Object)complex4));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertNotNull(complex9);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
Complex complex10 = complex9.ONE.multiply((-20.0));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex8));
assertTrue(complex9.equals((Object)complex4));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex10);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals((-20.0), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
Complex complex11 = complex1.pow(complex2);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertTrue(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertNotNull(complex11);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertSame(complex1, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertSame(complex11, complex8);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex6);
assertSame(complex11, complex5);
assertSame(complex11, complex4);
assertSame(complex11, complex1);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex2);
Complex complex12 = complex0.conjugate();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex0));
assertNotNull(complex12);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex12.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex0);
Complex complex13 = complex11.tanh();
assertFalse(complex13.equals((Object)complex2));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex12));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertTrue(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertTrue(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertNotNull(complex13);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex9);
assertSame(complex13, complex5);
assertSame(complex13, complex11);
assertSame(complex13, complex4);
assertSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertSame(complex13, complex8);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex0);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex12);
assertSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertSame(complex1, complex8);
assertSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertSame(complex1, complex4);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertSame(complex11, complex8);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex12);
assertSame(complex11, complex13);
assertSame(complex11, complex5);
assertSame(complex11, complex1);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
assertSame(complex11, complex4);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
}
@Test(timeout = 4000)
public void test067() throws Throwable {
Complex complex0 = Complex.INF;
assertNotNull(complex0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
Complex complex1 = Complex.valueOf(626.16);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex1, complex0);
Complex complex2 = Complex.valueOf((-3422.96359));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.I.multiply(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
String string0 = complex3.ONE.toString();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertEquals("(1.0, 0.0)", string0);
assertNotNull(string0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex3.INF.subtract(626.16);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
Complex complex5 = complex3.INF.add(complex0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
Complex complex6 = complex5.INF.log();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.7853981633974483, complex6.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
Complex complex7 = new Complex(626.16);
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
Complex complex8 = complex5.INF.add(complex7);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertTrue(complex8.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex8.getImaginary(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
Complex complex9 = complex7.cosh();
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex9);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertFalse(complex9.isInfinite());
assertEquals(4.333140717741918E271, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex3);
Complex complex10 = complex0.sqrt1z();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertNotNull(complex10);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
Complex complex11 = complex10.NaN.exp();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex3));
assertTrue(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex11);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex10.getImaginary(), 0.01);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex8);
Complex complex12 = complex2.createComplex(0.0, (-3422.96359));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(complex12);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals((-3422.96359), complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
Complex complex13 = complex1.add(complex2);
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertNotNull(complex13);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-2796.80359), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex11);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex11);
Complex complex14 = complex1.I.subtract(complex6);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex13));
assertTrue(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex10));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex6));
assertNotNull(complex14);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertFalse(complex5.isNaN());
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.7853981633974483, complex6.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.21460183660255172, complex14.getImaginary(), 0.01);
assertTrue(complex14.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex14.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex12);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex11);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex12);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex10);
Complex complex15 = complex13.I.asin();
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertNotNull(complex15);
assertEquals(0.0, complex15.getReal(), 0.01);
assertEquals(0.8813735870195428, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-2796.80359), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
Complex complex16 = complex15.NaN.atan();
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex6));
assertTrue(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertNotNull(complex16);
assertEquals(0.0, complex15.getReal(), 0.01);
assertEquals(0.8813735870195428, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertTrue(complex16.isNaN());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-2796.80359), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
Complex complex17 = complex7.multiply(0);
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex17);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
Complex complex18 = complex17.subtract(complex4);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex14));
assertTrue(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex17));
assertTrue(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex18);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex18.getImaginary(), 0.01);
assertTrue(complex18.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
Complex complex19 = complex18.ONE.add(626.16);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex14));
assertTrue(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex17));
assertTrue(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex18));
assertNotNull(complex19);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex18.getImaginary(), 0.01);
assertTrue(complex18.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertFalse(complex19.isNaN());
assertEquals(627.16, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
Complex complex20 = complex19.ONE.subtract(complex17);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex19));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex14));
assertTrue(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex17));
assertTrue(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex18));
assertNotNull(complex20);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex18.getImaginary(), 0.01);
assertTrue(complex18.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertFalse(complex19.isNaN());
assertEquals(627.16, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals(1.0, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
Complex complex21 = complex2.INF.subtract(6.283185307179586);
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex13));
assertTrue(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex14));
assertTrue(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex11));
assertTrue(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex6));
assertTrue(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex10));
assertNotNull(complex21);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex21.getImaginary(), 0.01);
assertTrue(complex21.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex21.getReal(), 0.01);
assertFalse(complex21.isNaN());
double double0 = complex3.abs();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex21));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex12));
assertEquals(626.16, double0, 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
double double1 = complex18.getArgument();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex19));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex21));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex20));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex21));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex19));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex20));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex21));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex13));
assertTrue(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex14));
assertTrue(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex17));
assertTrue(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertNotEquals(double1, double0, 0.01);
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex18));
assertEquals((-2.356194490192345), double1, 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(Double.NEGATIVE_INFINITY, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex18.getImaginary(), 0.01);
assertTrue(complex18.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(626.16, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex4.getImaginary(), 0.01);
assertTrue(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex4.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
Complex complex22 = complex17.ONE.acos();
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex21));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex20));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex14));
assertTrue(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex12));
assertNotNull(complex22);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex22.isInfinite());
assertEquals(0.0, complex22.getReal(), 0.01);
assertFalse(complex22.isNaN());
assertEquals(-0.0, complex22.getImaginary(), 0.01);
Complex complex23 = complex0.multiply(0);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex6));
assertTrue(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex20));
assertTrue(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex16));
assertTrue(complex23.equals((Object)complex8));
assertTrue(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex18));
assertNotNull(complex23);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertFalse(complex23.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex23.getReal(), 0.01);
assertTrue(complex23.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex23.getImaginary(), 0.01);
Complex complex24 = complex17.NaN.add(complex23);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex14));
assertTrue(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex23));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex21));
assertFalse(complex17.equals((Object)complex4));
assertTrue(complex17.equals((Object)complex22));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex20));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex23));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex22));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex6));
assertTrue(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex20));
assertTrue(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex16));
assertTrue(complex23.equals((Object)complex8));
assertTrue(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex7));
assertTrue(complex24.equals((Object)complex10));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex2));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex22));
assertNotNull(complex24);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex23.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex23.getReal(), 0.01);
assertTrue(complex23.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex23.getImaginary(), 0.01);
assertEquals(Double.NaN, complex24.getReal(), 0.01);
assertEquals(Double.NaN, complex24.getImaginary(), 0.01);
assertFalse(complex24.isInfinite());
assertTrue(complex24.isNaN());
Complex complex25 = complex7.atan();
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex24));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex23));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex22));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex25.equals((Object)complex7));
assertFalse(complex25.equals((Object)complex24));
assertFalse(complex25.equals((Object)complex13));
assertFalse(complex25.equals((Object)complex10));
assertFalse(complex25.equals((Object)complex15));
assertFalse(complex25.equals((Object)complex6));
assertFalse(complex25.equals((Object)complex3));
assertFalse(complex25.equals((Object)complex18));
assertFalse(complex25.equals((Object)complex12));
assertFalse(complex25.equals((Object)complex9));
assertFalse(complex25.equals((Object)complex22));
assertFalse(complex25.equals((Object)complex1));
assertFalse(complex25.equals((Object)complex4));
assertFalse(complex25.equals((Object)complex5));
assertFalse(complex25.equals((Object)complex0));
assertFalse(complex25.equals((Object)complex8));
assertFalse(complex25.equals((Object)complex23));
assertFalse(complex25.equals((Object)complex21));
assertFalse(complex25.equals((Object)complex16));
assertFalse(complex25.equals((Object)complex2));
assertFalse(complex25.equals((Object)complex14));
assertFalse(complex25.equals((Object)complex11));
assertFalse(complex25.equals((Object)complex19));
assertFalse(complex25.equals((Object)complex20));
assertFalse(complex25.equals((Object)complex17));
assertNotNull(complex25);
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex25.isInfinite());
assertFalse(complex25.isNaN());
assertEquals(1.5691992922512867, complex25.getReal(), 0.01);
assertEquals(0.0, complex25.getImaginary(), 0.01);
Complex complex26 = complex17.add(complex12);
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex25));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex24));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex4));
assertTrue(complex17.equals((Object)complex22));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex23));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex21));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex25));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex24));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex23));
assertFalse(complex2.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex21));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex22));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex22));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex25));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex24));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex23));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex26.equals((Object)complex5));
assertFalse(complex26.equals((Object)complex4));
assertFalse(complex26.equals((Object)complex20));
assertFalse(complex26.equals((Object)complex14));
assertFalse(complex26.equals((Object)complex23));
assertFalse(complex26.equals((Object)complex17));
assertFalse(complex26.equals((Object)complex19));
assertFalse(complex26.equals((Object)complex2));
assertFalse(complex26.equals((Object)complex16));
assertFalse(complex26.equals((Object)complex18));
assertFalse(complex26.equals((Object)complex15));
assertFalse(complex26.equals((Object)complex22));
assertFalse(complex26.equals((Object)complex1));
assertFalse(complex26.equals((Object)complex9));
assertFalse(complex26.equals((Object)complex24));
assertFalse(complex26.equals((Object)complex3));
assertFalse(complex26.equals((Object)complex25));
assertFalse(complex26.equals((Object)complex7));
assertFalse(complex26.equals((Object)complex11));
assertFalse(complex26.equals((Object)complex21));
assertTrue(complex26.equals((Object)complex12));
assertFalse(complex26.equals((Object)complex8));
assertFalse(complex26.equals((Object)complex6));
assertFalse(complex26.equals((Object)complex10));
assertFalse(complex26.equals((Object)complex0));
assertFalse(complex26.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex23));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex25));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex21));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex24));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex22));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex18));
assertNotNull(complex26);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getReal(), 0.01);
assertEquals((-3422.96359), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(626.16, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals((-3422.96359), complex26.getImaginary(), 0.01);
assertFalse(complex26.isInfinite());
assertEquals(0.0, complex26.getReal(), 0.01);
assertFalse(complex26.isNaN());
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals((-3422.96359), complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
Complex complex27 = complex1.atan();
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex24));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex25));
assertFalse(complex1.equals((Object)complex23));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex26));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex27.equals((Object)complex14));
assertFalse(complex27.equals((Object)complex23));
assertFalse(complex27.equals((Object)complex20));
assertFalse(complex27.equals((Object)complex2));
assertFalse(complex27.equals((Object)complex5));
assertFalse(complex27.equals((Object)complex15));
assertFalse(complex27.equals((Object)complex1));
assertFalse(complex27.equals((Object)complex12));
assertFalse(complex27.equals((Object)complex22));
assertFalse(complex27.equals((Object)complex3));
assertFalse(complex27.equals((Object)complex18));
assertFalse(complex27.equals((Object)complex26));
assertFalse(complex27.equals((Object)complex9));
assertFalse(complex27.equals((Object)complex4));
assertFalse(complex27.equals((Object)complex11));
assertFalse(complex27.equals((Object)complex24));
assertFalse(complex27.equals((Object)complex13));
assertFalse(complex27.equals((Object)complex6));
assertTrue(complex27.equals((Object)complex25));
assertFalse(complex27.equals((Object)complex8));
assertFalse(complex27.equals((Object)complex7));
assertFalse(complex27.equals((Object)complex10));
assertFalse(complex27.equals((Object)complex19));
assertFalse(complex27.equals((Object)complex0));
assertFalse(complex27.equals((Object)complex21));
assertFalse(complex27.equals((Object)complex16));
assertFalse(complex27.equals((Object)complex17));
assertNotNull(complex27);
assertEquals(626.16, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.5691992922512867, complex27.getReal(), 0.01);
assertEquals(0.0, complex27.getImaginary(), 0.01);
assertFalse(complex27.isNaN());
assertFalse(complex27.isInfinite());
try {
complex27.nthRoot((-706));
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: -706
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test068() throws Throwable {
Complex complex0 = Complex.INF;
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.ONE.atan();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = Complex.valueOf(2414.0);
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2414.0, complex2.getReal(), 0.01);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.ONE.sinh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex0.ZERO.subtract(complex3);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-1.1752011936438014), complex4.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
Complex complex5 = complex3.INF.sinh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
Complex complex6 = complex5.INF.reciprocal();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
Complex complex7 = complex1.I.log();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(1.5707963267948966, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
Complex complex8 = complex0.ZERO.acos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
Complex complex9 = complex8.I.sinh();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertEquals(0.8414709848078965, complex9.getImaginary(), 0.01);
assertEquals(0.0, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
Complex complex10 = complex1.ONE.conjugate();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertNotNull(complex10);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
List<Complex> list0 = complex0.INF.nthRoot(1);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertNotNull(list0);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(1, list0.size());
assertFalse(list0.isEmpty());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertTrue(list0.contains(complex0));
assertFalse(list0.contains(complex4));
Complex complex11 = complex0.multiply(0.0);
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex11);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertTrue(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex11, complex3);
assertSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
Complex complex12 = complex11.log();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertNotNull(complex12);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertTrue(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertEquals(0.7853981633974483, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex11, complex3);
assertSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
Complex complex13 = complex12.I.pow((-2588.51));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex1));
assertNotNull(complex13);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertTrue(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertEquals(0.7853981633974483, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals((-0.7181262977633245), complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals(0.6959127965921743, complex13.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex11, complex13);
assertSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex13);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex1);
double double0 = complex1.abs();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertEquals(0.7853981633974483, double0, 0.01);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
Complex complex14 = Complex.valueOf(446.0, 2414.0);
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex5));
assertNotNull(complex14);
assertFalse(complex14.isNaN());
assertEquals(446.0, complex14.getReal(), 0.01);
assertEquals(2414.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex5);
complex2.hashCode();
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2414.0, complex2.getReal(), 0.01);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex14);
Complex complex15 = complex1.createComplex(92.90866061083, 0.0);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertNotNull(complex15);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(92.90866061083, complex15.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
Complex complex16 = Complex.valueOf(0.0);
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex14));
assertTrue(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex1));
assertNotNull(complex16);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex1);
String string0 = complex14.ONE.toString();
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex5));
assertEquals("(1.0, 0.0)", string0);
assertNotNull(string0);
assertFalse(complex14.isNaN());
assertEquals(446.0, complex14.getReal(), 0.01);
assertEquals(2414.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex5);
ComplexField complexField0 = complex15.getField();
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertNotNull(complexField0);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(92.90866061083, complex15.getReal(), 0.01);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
Complex complex17 = complex15.subtract(446.0);
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex11));
assertNotNull(complex17);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(92.90866061083, complex15.getReal(), 0.01);
assertEquals((-353.09133938917), complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex17);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex11);
boolean boolean0 = complex14.equals(complex5);
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex11));
assertFalse(boolean0);
assertFalse(complex14.isNaN());
assertEquals(446.0, complex14.getReal(), 0.01);
assertEquals(2414.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex5);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex17);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex11);
Complex complex18 = complex17.exp();
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex11));
assertNotNull(complex18);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(92.90866061083, complex15.getReal(), 0.01);
assertEquals((-353.09133938917), complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertEquals(4.5121101740854395E-154, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex18);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex18);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex11);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex11);
Complex complex19 = complex10.sqrt1z();
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex4));
assertTrue(complex19.equals((Object)complex6));
assertTrue(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex19);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals(0.0, complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex17);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex1);
Complex complex20 = complex17.divide(complex19);
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex4));
assertTrue(complex19.equals((Object)complex6));
assertTrue(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex8));
assertTrue(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex18));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex20);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(92.90866061083, complex15.getReal(), 0.01);
assertEquals((-353.09133938917), complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals(0.0, complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertTrue(complex20.isNaN());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex17);
assertSame(complex0, complex11);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex20);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex19);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex18);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex19);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex18);
assertNotSame(complex17, complex20);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex11);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex20);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex9);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex19);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex20);
Complex complex21 = complex15.divide(0.0);
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex20));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex9));
assertTrue(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex13));
assertNotNull(complex21);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.7853981633974483, complex1.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(92.90866061083, complex15.getReal(), 0.01);
assertTrue(complex21.isNaN());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex17);
assertSame(complex0, complex11);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex21);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex20);
assertNotSame(complex15, complex21);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex19);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex18);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex10);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex15);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex7);
assertNotSame(complex21, complex6);
assertNotSame(complex21, complex3);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex4);
assertNotSame(complex21, complex0);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex1);
assertNotSame(complex21, complex19);
assertSame(complex21, complex20);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex14);
assertNotSame(complex21, complex13);
}
@Test(timeout = 4000)
public void test069() throws Throwable {
Complex complex0 = Complex.valueOf(0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.INF.add(0.0);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
complex0.hashCode();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
Complex complex2 = complex0.I.pow(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.sqrt();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex3.I.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals((-1.0), complex4.getImaginary(), 0.01);
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex1.acos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
double double0 = complex2.getReal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex5));
assertEquals(Double.NaN, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
Complex complex6 = complex3.add(0.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertTrue(complex6.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertSame(complex6, complex5);
Complex complex7 = complex3.createComplex((-578.6017751701), 0.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals((-578.6017751701), complex7.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
}
@Test(timeout = 4000)
public void test070() throws Throwable {
Complex complex0 = new Complex(1.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.I.multiply(522);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(522.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.I.subtract(1.0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-1.0), complex2.getReal(), 0.01);
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.log();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.NaN.conjugate();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
Complex complex5 = complex2.cosh();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-1.0), complex2.getReal(), 0.01);
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-0.9888977057628651), complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(0.8337300251311491, complex5.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
Complex complex6 = complex3.subtract(complex0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
complex3.NaN.hashCode();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex7 = Complex.valueOf(1.0);
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(1.0, complex7.getReal(), 0.01);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
Complex complex8 = complex3.ONE.cosh();
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(1.5430806348152437, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
Complex complex9 = complex6.multiply(complex5);
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-1.0), complex2.getReal(), 0.01);
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals((-0.9888977057628651), complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(0.8337300251311491, complex5.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertEquals(0.9888977057628651, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals((-0.8337300251311491), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
ComplexField complexField0 = complex7.ONE.getField();
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(1.0, complex7.getReal(), 0.01);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
Complex complex10 = complex6.ZERO.multiply(complex7);
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex3));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(1.0, complex7.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(0.0, complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex10);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
Complex complex11 = complex2.subtract((-903.3440583533));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex1));
assertNotNull(complex11);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-1.0), complex2.getReal(), 0.01);
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(902.3440583533, complex11.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex1);
Complex complex12 = complex2.sqrt1z();
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex6));
assertNotNull(complex12);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-1.0), complex2.getReal(), 0.01);
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.7861513777574233, complex12.getImaginary(), 0.01);
assertEquals(1.272019649514069, complex12.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex11);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex6);
Complex complex13 = Complex.valueOf((-69.4613), 1.0);
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertNotNull(complex13);
assertEquals(1.0, complex13.getImaginary(), 0.01);
assertEquals((-69.4613), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
Complex complex14 = complex0.reciprocal();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertNotNull(complex14);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
Complex complex15 = complex14.ONE.atan();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex5));
assertNotNull(complex15);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.7853981633974483, complex15.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex5);
Complex complex16 = complex14.multiply(1);
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex2));
assertTrue(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex13));
assertTrue(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex9));
assertTrue(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex10));
assertNotNull(complex16);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex16.isNaN());
assertFalse(complex16.isInfinite());
assertEquals(-0.0, complex16.getImaginary(), 0.01);
assertEquals(1.0, complex16.getReal(), 0.01);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex10);
Complex complex17 = complex14.sin();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex15));
assertNotNull(complex17);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.8414709848078965, complex17.getReal(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(-0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex15);
Complex complex18 = complex1.divide(complex11);
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex1));
assertNotNull(complex18);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(522.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals((-1.0), complex2.getReal(), 0.01);
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex18.isNaN());
assertEquals(6.410998033067332E-4, complex18.getReal(), 0.01);
assertEquals(0.5784925983253001, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(902.3440583533, complex11.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex15);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex15);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex17);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex18);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex1);
Complex complex19 = complex14.atan();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex3));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex11));
assertNotNull(complex19);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.7853981633974483, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex19);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex11);
Complex complex20 = complex19.conjugate();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex19));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex3));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex13));
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex4));
assertNotNull(complex20);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.7853981633974483, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertFalse(complex20.isNaN());
assertEquals(-0.0, complex20.getImaginary(), 0.01);
assertEquals(0.7853981633974483, complex20.getReal(), 0.01);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex19);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex20);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex20);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex11);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex4);
Complex complex21 = complex15.cosh();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex19));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex20));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex14));
assertTrue(complex15.equals((Object)complex20));
assertFalse(complex15.equals((Object)complex6));
assertTrue(complex15.equals((Object)complex19));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex3));
assertNotNull(complex21);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.7853981633974483, complex15.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
assertEquals(1.3246090892520057, complex21.getReal(), 0.01);
assertEquals(0.0, complex21.getImaginary(), 0.01);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex21);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex19);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex20);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex20);
assertNotSame(complex15, complex19);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex21);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex18);
assertNotSame(complex21, complex4);
assertNotSame(complex21, complex7);
assertNotSame(complex21, complex0);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex1);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex15);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex19);
assertNotSame(complex21, complex10);
assertNotSame(complex21, complex14);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex6);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex20);
assertNotSame(complex21, complex3);
Complex complex22 = Complex.valueOf(0.0, (double) 1);
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex14));
assertNotNull(complex22);
assertEquals(1.0, complex22.getImaginary(), 0.01);
assertEquals(0.0, complex22.getReal(), 0.01);
assertFalse(complex22.isInfinite());
assertFalse(complex22.isNaN());
assertNotSame(complex22, complex19);
assertNotSame(complex22, complex17);
assertNotSame(complex22, complex20);
assertNotSame(complex22, complex10);
assertNotSame(complex22, complex7);
assertNotSame(complex22, complex18);
assertNotSame(complex22, complex9);
assertNotSame(complex22, complex21);
assertNotSame(complex22, complex5);
assertNotSame(complex22, complex4);
assertNotSame(complex22, complex2);
assertNotSame(complex22, complex0);
assertNotSame(complex22, complex3);
assertNotSame(complex22, complex13);
assertNotSame(complex22, complex11);
assertNotSame(complex22, complex16);
assertNotSame(complex22, complex12);
assertNotSame(complex22, complex6);
assertNotSame(complex22, complex8);
assertNotSame(complex22, complex1);
assertNotSame(complex22, complex15);
assertNotSame(complex22, complex14);
Complex complex23 = complex13.reciprocal();
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex21));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex22));
assertNotNull(complex23);
assertEquals((-0.014393522487654986), complex23.getReal(), 0.01);
assertFalse(complex23.isInfinite());
assertEquals((-2.072164282507668E-4), complex23.getImaginary(), 0.01);
assertFalse(complex23.isNaN());
assertEquals(1.0, complex13.getImaginary(), 0.01);
assertEquals((-69.4613), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertNotSame(complex23, complex14);
assertNotSame(complex23, complex20);
assertNotSame(complex23, complex15);
assertNotSame(complex23, complex9);
assertNotSame(complex23, complex8);
assertNotSame(complex23, complex17);
assertNotSame(complex23, complex6);
assertNotSame(complex23, complex11);
assertNotSame(complex23, complex12);
assertNotSame(complex23, complex19);
assertNotSame(complex23, complex1);
assertNotSame(complex23, complex16);
assertNotSame(complex23, complex21);
assertNotSame(complex23, complex3);
assertNotSame(complex23, complex13);
assertNotSame(complex23, complex5);
assertNotSame(complex23, complex0);
assertNotSame(complex23, complex18);
assertNotSame(complex23, complex2);
assertNotSame(complex23, complex10);
assertNotSame(complex23, complex4);
assertNotSame(complex23, complex7);
assertNotSame(complex23, complex22);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex23);
assertNotSame(complex13, complex20);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex19);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex18);
assertNotSame(complex13, complex21);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex22);
Complex complex24 = complex19.multiply(complex23);
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex21));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex19));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex23));
assertFalse(complex14.equals((Object)complex20));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex22));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex14));
assertTrue(complex19.equals((Object)complex20));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex22));
assertFalse(complex19.equals((Object)complex3));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex21));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex23));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex2));
assertFalse(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex11));
assertFalse(complex24.equals((Object)complex10));
assertFalse(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex23));
assertFalse(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex21));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex22));
assertNotNull(complex24);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.7853981633974483, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals((-0.014393522487654986), complex23.getReal(), 0.01);
assertFalse(complex23.isInfinite());
assertEquals((-2.072164282507668E-4), complex23.getImaginary(), 0.01);
assertFalse(complex23.isNaN());
assertFalse(complex24.isInfinite());
assertFalse(complex24.isNaN());
assertEquals((-0.011304646126624096), complex24.getReal(), 0.01);
assertEquals((-1.6274740217393137E-4), complex24.getImaginary(), 0.01);
assertEquals(1.0, complex13.getImaginary(), 0.01);
assertEquals((-69.4613), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertNotSame(complex14, complex21);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex24);
Complex complex25 = complex20.exp();
assertFalse(complex14.equals((Object)complex21));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex24));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex19));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex23));
assertFalse(complex14.equals((Object)complex20));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex22));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex24));
assertFalse(complex19.equals((Object)complex14));
assertTrue(complex19.equals((Object)complex20));
assertFalse(complex19.equals((Object)complex22));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex3));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex21));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex23));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex13));
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex22));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex23));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex24));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex25.equals((Object)complex22));
assertFalse(complex25.equals((Object)complex13));
assertFalse(complex25.equals((Object)complex1));
assertFalse(complex25.equals((Object)complex5));
assertFalse(complex25.equals((Object)complex24));
assertFalse(complex25.equals((Object)complex12));
assertFalse(complex25.equals((Object)complex9));
assertFalse(complex25.equals((Object)complex8));
assertFalse(complex25.equals((Object)complex7));
assertFalse(complex25.equals((Object)complex20));
assertFalse(complex25.equals((Object)complex2));
assertFalse(complex25.equals((Object)complex21));
assertFalse(complex25.equals((Object)complex4));
assertFalse(complex25.equals((Object)complex18));
assertFalse(complex25.equals((Object)complex17));
assertFalse(complex25.equals((Object)complex11));
assertFalse(complex25.equals((Object)complex0));
assertFalse(complex25.equals((Object)complex19));
assertFalse(complex25.equals((Object)complex15));
assertFalse(complex25.equals((Object)complex23));
assertFalse(complex25.equals((Object)complex14));
assertFalse(complex25.equals((Object)complex10));
assertFalse(complex25.equals((Object)complex6));
assertFalse(complex25.equals((Object)complex16));
assertFalse(complex25.equals((Object)complex3));
assertNotNull(complex25);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.7853981633974483, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertFalse(complex20.isNaN());
assertEquals(-0.0, complex20.getImaginary(), 0.01);
assertEquals(0.7853981633974483, complex20.getReal(), 0.01);
assertEquals(2.1932800507380152, complex25.getReal(), 0.01);
assertEquals(-0.0, complex25.getImaginary(), 0.01);
assertFalse(complex25.isInfinite());
assertFalse(complex25.isNaN());
Complex complex26 = complex24.sqrt1z();
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex25));
assertFalse(complex14.equals((Object)complex24));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex23));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex21));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex19));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex20));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex25));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex14));
assertTrue(complex19.equals((Object)complex20));
assertFalse(complex19.equals((Object)complex10));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex21));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex25));
assertFalse(complex19.equals((Object)complex24));
assertFalse(complex19.equals((Object)complex22));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex23));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex25));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex24));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex23));
assertFalse(complex24.equals((Object)complex25));
assertFalse(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex18));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex7));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex2));
assertFalse(complex24.equals((Object)complex11));
assertFalse(complex24.equals((Object)complex10));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex26.equals((Object)complex4));
assertFalse(complex26.equals((Object)complex17));
assertFalse(complex26.equals((Object)complex2));
assertFalse(complex26.equals((Object)complex0));
assertFalse(complex26.equals((Object)complex24));
assertFalse(complex26.equals((Object)complex21));
assertFalse(complex26.equals((Object)complex8));
assertFalse(complex26.equals((Object)complex18));
assertFalse(complex26.equals((Object)complex22));
assertFalse(complex26.equals((Object)complex20));
assertFalse(complex26.equals((Object)complex7));
assertFalse(complex26.equals((Object)complex6));
assertFalse(complex26.equals((Object)complex12));
assertFalse(complex26.equals((Object)complex9));
assertFalse(complex26.equals((Object)complex5));
assertFalse(complex26.equals((Object)complex23));
assertFalse(complex26.equals((Object)complex14));
assertFalse(complex26.equals((Object)complex25));
assertFalse(complex26.equals((Object)complex1));
assertFalse(complex26.equals((Object)complex19));
assertFalse(complex26.equals((Object)complex11));
assertFalse(complex26.equals((Object)complex10));
assertFalse(complex26.equals((Object)complex15));
assertFalse(complex26.equals((Object)complex13));
assertFalse(complex26.equals((Object)complex16));
assertFalse(complex26.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex23));
assertFalse(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex21));
assertFalse(complex13.equals((Object)complex24));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex25));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex22));
assertNotNull(complex26);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.7853981633974483, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals((-0.014393522487654986), complex23.getReal(), 0.01);
assertFalse(complex23.isInfinite());
assertEquals((-2.072164282507668E-4), complex23.getImaginary(), 0.01);
assertFalse(complex23.isNaN());
assertFalse(complex24.isInfinite());
assertFalse(complex24.isNaN());
assertEquals((-0.011304646126624096), complex24.getReal(), 0.01);
assertEquals((-1.6274740217393137E-4), complex24.getImaginary(), 0.01);
assertEquals((-1.8399193352564683E-6), complex26.getImaginary(), 0.01);
assertEquals(0.9999361136922968, complex26.getReal(), 0.01);
assertFalse(complex26.isInfinite());
assertFalse(complex26.isNaN());
assertEquals(1.0, complex13.getImaginary(), 0.01);
assertEquals((-69.4613), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
}
@Test(timeout = 4000)
public void test071() throws Throwable {
Complex complex0 = new Complex(0.0, 1.8609623908996582);
assertNotNull(complex0);
assertEquals(1.8609623908996582, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.reciprocal();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(1.8609623908996582, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-0.5373563726435991), complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
}
@Test(timeout = 4000)
public void test072() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
Complex complex1 = Complex.INF;
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertNotSame(complex1, complex0);
Complex complex2 = complex0.pow(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.pow(complex1);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertTrue(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertTrue(complex3.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex0.ONE.sqrt();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(1.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
Complex complex5 = complex0.sqrt1z();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
boolean boolean0 = complex0.isInfinite();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(boolean0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
double double0 = complex0.abs();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertEquals(1.0, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
Complex complex6 = complex1.cosh();
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
Complex complex7 = complex5.multiply((-1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertEquals((-1.4142135623730951), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
Complex complex8 = complex1.conjugate();
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex8);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
Complex complex9 = complex7.pow(1529.3);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertEquals((-1.4142135623730951), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertFalse(complex9.isNaN());
assertEquals((-8.94962564953665E229), complex9.getReal(), 0.01);
assertEquals(1.231810293900639E230, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex9);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
Complex complex10 = complex9.add(1529.3);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex2));
assertTrue(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(1.4142135623730951, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertEquals((-1.4142135623730951), complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertFalse(complex9.isNaN());
assertEquals((-8.94962564953665E229), complex9.getReal(), 0.01);
assertEquals(1.231810293900639E230, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals((-8.94962564953665E229), complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(1.231810293900639E230, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex9);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex5);
}
@Test(timeout = 4000)
public void test073() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
Complex complex1 = Complex.INF;
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ZERO.acos();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.INF.sin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = complex1.INF.tan();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
Complex complex5 = complex4.pow(0.0);
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex0);
assertSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex5, complex3);
assertSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
Complex complex6 = complex0.subtract(complex1);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
Complex complex7 = complex6.NaN.atan();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertSame(complex7, complex5);
Complex complex8 = complex6.INF.log();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertEquals(0.7853981633974483, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
Complex complex9 = complex8.INF.log();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertEquals(0.7853981633974483, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex9.getReal(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(0.7853981633974483, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
boolean boolean0 = complex0.isNaN();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(boolean0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
Complex complex10 = Complex.valueOf(1.033464507572145E142, 1.033464507572145E142);
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertNotNull(complex10);
assertEquals(1.033464507572145E142, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(1.033464507572145E142, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
Complex complex11 = complex6.divide(complex8);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertTrue(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex10));
assertTrue(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertTrue(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertTrue(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertEquals(0.7853981633974483, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex9);
Complex complex12 = complex8.pow(1.033464507572145E142);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertTrue(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex4));
assertTrue(complex12.equals((Object)complex7));
assertTrue(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertNotNull(complex12);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertEquals(0.7853981633974483, complex8.getImaginary(), 0.01);
assertTrue(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertTrue(complex12.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex3);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
boolean boolean1 = complex4.isNaN();
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex12));
assertTrue(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex10));
assertFalse(boolean1 == boolean0);
assertTrue(boolean1);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex11);
assertSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertSame(complex4, complex5);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex10);
}
@Test(timeout = 4000)
public void test074() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, Double.POSITIVE_INFINITY);
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
Complex complex1 = (Complex)complex0.INF.readResolve();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
List<Complex> list0 = complex2.ONE.nthRoot(1405);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(list0);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(1405, list0.size());
assertFalse(list0.isEmpty());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertFalse(list0.contains(complex1));
Complex complex3 = complex2.multiply((-187));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(-0.0, complex3.getReal(), 0.01);
assertEquals((-187.0), complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex0.createComplex(297.428864, (-1740.317));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(297.428864, complex4.getReal(), 0.01);
assertEquals((-1740.317), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
}
@Test(timeout = 4000)
public void test075() throws Throwable {
Complex complex0 = new Complex(Double.POSITIVE_INFINITY);
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = Complex.valueOf(Double.POSITIVE_INFINITY);
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.INF.multiply(complex0);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertTrue(complex2.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = Complex.NaN;
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex2.ONE.multiply(complex3);
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertTrue(complex2.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getImaginary(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertSame(complex4, complex3);
List<Complex> list0 = complex1.INF.nthRoot(96);
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertNotNull(list0);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1, list0.size());
assertFalse(list0.isEmpty());
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertFalse(list0.contains(complex1));
assertTrue(list0.contains(complex2));
Complex complex5 = complex0.multiply(complex1);
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertTrue(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
Complex complex6 = complex5.INF.tanh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex5, complex4);
assertSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex6);
assertNotSame(complex6, complex0);
assertSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
Complex complex7 = complex5.I.negate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertNotNull(complex7);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertTrue(complex5.isInfinite());
assertFalse(complex7.isInfinite());
assertEquals(-0.0, complex7.getReal(), 0.01);
assertEquals((-1.0), complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex5, complex4);
assertSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
Complex complex8 = complex1.log();
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex1));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex8.getReal(), 0.01);
assertTrue(complex8.isInfinite());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isNaN());
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
double double0 = complex0.abs();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertEquals(Double.POSITIVE_INFINITY, double0, 0.01);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
boolean boolean0 = complex6.isInfinite();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(boolean0);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex5, complex4);
assertSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex6, complex0);
assertSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertSame(complex6, complex3);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
Complex complex9 = complex6.multiply(complex2);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertNotNull(complex9);
assertFalse(complex0.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertTrue(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertTrue(complex2.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex2.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertTrue(complex5.isInfinite());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex3);
assertSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex5, complex4);
assertSame(complex5, complex2);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex6);
assertNotSame(complex6, complex0);
assertSame(complex6, complex4);
assertSame(complex6, complex9);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex7);
assertSame(complex6, complex3);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex0);
assertSame(complex9, complex6);
}
@Test(timeout = 4000)
public void test076() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.add(0.0);
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.sinh();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.8414709848078965, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.INF.reciprocal();
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex2.ONE.asin();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.8414709848078965, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
double double0 = complex2.getReal();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.8414709848078965, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
Complex complex5 = complex0.asin();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex5.isNaN());
assertEquals(0.8813735870195428, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
Complex complex6 = Complex.valueOf(2.3508325311148225E-8, 0.0);
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(2.3508325311148225E-8, complex6.getReal(), 0.01);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
Complex complex7 = complex6.I.negate();
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(2.3508325311148225E-8, complex6.getReal(), 0.01);
assertEquals((-1.0), complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(-0.0, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
Complex complex8 = complex0.sin();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(1.1752011936438014, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
Complex complex9 = (Complex)complex4.readResolve();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.8414709848078965, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex9.isInfinite());
assertEquals(1.5707963267948966, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(-0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
Complex complex10 = complex4.acos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex10);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.8414709848078965, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(1.0232274785475506, complex10.getImaginary(), 0.01);
assertEquals(0.0, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertFalse(complex10.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex0);
Complex complex11 = complex2.atan();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex1.isNaN());
assertEquals(1.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.8414709848078965, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(1.2261911708835171, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
Complex complex12 = Complex.valueOf((-2383.8502868412));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex9));
assertNotNull(complex12);
assertFalse(complex12.isInfinite());
assertEquals((-2383.8502868412), complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex9);
Complex complex13 = complex12.cosh();
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex11));
assertNotNull(complex13);
assertFalse(complex12.isInfinite());
assertEquals((-2383.8502868412), complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex13.getReal(), 0.01);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex4);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex11);
}
@Test(timeout = 4000)
public void test077() throws Throwable {
Complex complex0 = new Complex((-1728.66484955));
assertNotNull(complex0);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.createComplex(0, 797.126739284144);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex3.NaN.acos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
ComplexField complexField0 = complex2.INF.getField();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complexField0);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
Complex complex5 = complex2.I.multiply(0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
Complex complex6 = complex5.INF.multiply(0);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertTrue(complex6.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
String string0 = complex2.toString();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertEquals("(-1.0070083253749793, 0.0)", string0);
assertNotNull(string0);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
double double0 = complex1.getReal();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertEquals((-1.5707963267948966), double0, 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
boolean boolean0 = complex2.isInfinite();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(boolean0);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
Complex complex7 = complex1.multiply(363);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
Complex complex8 = complex7.sqrt();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertNotNull(complex8);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(34.94335142207963, complex8.getReal(), 0.01);
assertEquals(42.323006453151486, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
Complex complex9 = (Complex)complex4.readResolve();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
Complex complex10 = complex3.NaN.multiply((-1.5707963267948966));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertTrue(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex10);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
Complex complex11 = complex10.ZERO.cos();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertTrue(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertNotNull(complex11);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertEquals(1.0, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(-0.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex0);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex1);
complex8.hashCode();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex0));
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(34.94335142207963, complex8.getReal(), 0.01);
assertEquals(42.323006453151486, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex11);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex0);
Complex complex12 = complex7.cos();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex11));
assertNotNull(complex12);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex11);
double double1 = complex12.NaN.abs();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertNotEquals(double1, double0, 0.01);
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex11));
assertEquals(Double.NaN, double1, 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex11);
Complex complex13 = complex4.NaN.tanh();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex5));
assertNotNull(complex13);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertSame(complex13, complex10);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex11);
assertSame(complex13, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex11);
assertSame(complex4, complex10);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex9);
assertSame(complex4, complex13);
Complex complex14 = complex2.conjugate();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex5));
assertTrue(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex12));
assertNotNull(complex14);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals((-1.0070083253749793), complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals((-1.0070083253749793), complex14.getReal(), 0.01);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
double double2 = complex12.getReal();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertNotEquals(double2, double1, 0.01);
assertNotEquals(double2, double0, 0.01);
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertEquals(Double.POSITIVE_INFINITY, double2, 0.01);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
Complex complex15 = complex7.multiply(complex13);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex2));
assertTrue(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex15);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertTrue(complex15.isNaN());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
Complex complex16 = Complex.I;
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex13));
assertNotNull(complex16);
assertFalse(complex16.isNaN());
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(1.0, complex16.getImaginary(), 0.01);
Complex complex17 = complex15.ONE.subtract(complex16);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertTrue(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex2));
assertTrue(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex17);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertTrue(complex15.isNaN());
assertFalse(complex16.isNaN());
assertEquals(0.0, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(1.0, complex16.getImaginary(), 0.01);
assertEquals(1.0, complex17.getReal(), 0.01);
assertEquals((-1.0), complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertFalse(complex17.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
Complex complex18 = complex4.divide(complex0);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertTrue(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex17));
assertTrue(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex0));
assertNotNull(complex18);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertTrue(complex18.isNaN());
Complex complex19 = complex12.cosh();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertTrue(complex19.equals((Object)complex4));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex11));
assertTrue(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex2));
assertTrue(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex7));
assertTrue(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex5));
assertTrue(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex19);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertTrue(complex19.isNaN());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
Complex complex20 = (Complex)complex12.readResolve();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex7));
assertTrue(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex20);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex20.getImaginary(), 0.01);
assertTrue(complex20.isInfinite());
assertFalse(complex20.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex20.getReal(), 0.01);
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
Complex complex21 = complex12.asin();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex8));
assertTrue(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex20));
assertTrue(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex0));
assertNotNull(complex21);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertTrue(complex21.isNaN());
Complex complex22 = complex12.acos();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex21));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex20));
assertTrue(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex3));
assertTrue(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex5));
assertNotNull(complex22);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(Double.NaN, complex22.getImaginary(), 0.01);
assertFalse(complex22.isInfinite());
assertTrue(complex22.isNaN());
assertEquals(Double.NaN, complex22.getReal(), 0.01);
complex7.hashCode();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex22));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex20));
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
Complex complex23 = complex21.sqrt1z();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex22));
assertTrue(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex21));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex18));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex22));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex8));
assertTrue(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex20));
assertTrue(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex0));
assertTrue(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex14));
assertTrue(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex20));
assertNotNull(complex23);
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertTrue(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex12.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals((-1.5707963267948966), complex1.getReal(), 0.01);
assertEquals(8.148251723038108, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(2957.815375462833, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals((-570.1990666265475), complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertTrue(complex21.isNaN());
assertEquals(Double.NaN, complex23.getReal(), 0.01);
assertEquals(Double.NaN, complex23.getImaginary(), 0.01);
assertFalse(complex23.isInfinite());
assertTrue(complex23.isNaN());
Complex complex24 = complex4.cosh();
assertFalse(complex24.equals((Object)complex2));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex7));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex6));
assertTrue(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex11));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex14));
assertTrue(complex24.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex21));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex22));
assertFalse(complex3.equals((Object)complex23));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex11));
assertTrue(complex4.equals((Object)complex19));
assertTrue(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex17));
assertNotNull(complex24);
assertEquals(Double.NaN, complex24.getReal(), 0.01);
assertEquals(Double.NaN, complex24.getImaginary(), 0.01);
assertFalse(complex24.isInfinite());
assertTrue(complex24.isNaN());
assertEquals((-1728.66484955), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(797.126739284144, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
}
@Test(timeout = 4000)
public void test078() throws Throwable {
Complex complex0 = Complex.NaN;
assertNotNull(complex0);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
double double0 = complex0.abs();
assertEquals(Double.NaN, double0, 0.01);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
String string0 = complex0.I.toString();
assertEquals("(0.0, 1.0)", string0);
assertNotNull(string0);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
Complex complex1 = complex0.reciprocal();
assertNotNull(complex1);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertSame(complex0, complex1);
assertSame(complex1, complex0);
Complex complex2 = complex1.ZERO.multiply(1);
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.ONE.asin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex0.tan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertSame(complex4, complex0);
assertSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
Complex complex5 = complex4.I.add((double) 1);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(1.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(1.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
Complex complex6 = complex2.ONE.sin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
Complex complex7 = complex6.NaN.divide(1.8810608386993408);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(0.8414709848078965, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertSame(complex0, complex1);
assertSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex7);
assertSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertSame(complex7, complex1);
assertSame(complex7, complex4);
assertSame(complex7, complex0);
assertNotSame(complex7, complex2);
Complex complex8 = complex1.sin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertSame(complex0, complex1);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertSame(complex1, complex8);
assertSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertSame(complex1, complex7);
assertSame(complex1, complex0);
assertNotSame(complex1, complex5);
assertNotSame(complex8, complex2);
assertSame(complex8, complex7);
assertSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertSame(complex8, complex4);
assertNotSame(complex8, complex3);
Complex complex9 = complex0.createComplex(2.0, 0.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(2.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertSame(complex0, complex1);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
Complex complex10 = complex0.conjugate();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertNotNull(complex10);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertSame(complex0, complex1);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex10, complex9);
assertSame(complex10, complex7);
assertNotSame(complex10, complex3);
assertSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertSame(complex10, complex0);
assertSame(complex10, complex8);
assertSame(complex10, complex4);
assertNotSame(complex10, complex2);
double double1 = complex9.getImaginary();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertNotEquals(double1, double0, 0.01);
assertEquals(0.0, double1, 0.01);
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(2.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertSame(complex0, complex1);
assertSame(complex0, complex8);
assertSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
Complex complex11 = Complex.valueOf(2.0, Double.NaN);
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex5));
assertNotNull(complex11);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex5);
assertSame(complex11, complex4);
assertSame(complex11, complex10);
assertSame(complex11, complex1);
assertSame(complex11, complex0);
assertSame(complex11, complex8);
assertSame(complex11, complex7);
}
@Test(timeout = 4000)
public void test079() throws Throwable {
Complex complex0 = Complex.ONE;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.NaN.atan();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.ZERO.multiply(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.atan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.7853981633974483, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
Complex complex4 = complex0.sinh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
Complex complex5 = complex0.multiply((-2.238614484037969E-159));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-2.238614484037969E-159), complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
Complex complex6 = complex4.NaN.acos();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
double double0 = complex1.getReal();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex5));
assertEquals(Double.NaN, double0, 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertSame(complex1, complex6);
Complex complex7 = complex4.createComplex((-2.238614484037969E-159), Double.NaN);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex6));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-2.238614484037969E-159), complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
Complex complex8 = complex7.NaN.negate();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-2.238614484037969E-159), complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertTrue(complex7.isNaN());
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
assertSame(complex8, complex2);
Complex complex9 = complex1.add(complex5);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertTrue(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals((-2.238614484037969E-159), complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex7);
assertSame(complex1, complex8);
assertSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertSame(complex1, complex6);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertSame(complex9, complex8);
assertSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertSame(complex9, complex2);
complex9.hashCode();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertTrue(complex9.equals((Object)complex7));
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals((-2.238614484037969E-159), complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex7);
assertSame(complex1, complex8);
assertSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertSame(complex1, complex6);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertSame(complex9, complex8);
assertSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertSame(complex9, complex2);
Complex complex10 = complex3.pow((-2.238614484037969E-159));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.7853981633974483, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex10.isInfinite());
assertEquals(1.0, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex10);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
double double1 = complex0.abs();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertNotEquals(double1, double0, 0.01);
assertEquals(1.0, double1, 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
Complex complex11 = complex3.acos();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.7853981633974483, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.6674572160283838, complex11.getReal(), 0.01);
assertEquals(-0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex10);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
Complex complex12 = complex3.divide(1.0);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex11));
assertTrue(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.7853981633974483, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.7853981633974483, complex12.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
Complex complex13 = complex12.ZERO.negate();
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex11));
assertTrue(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertNotNull(complex13);
assertEquals(-0.0, complex13.getReal(), 0.01);
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.7853981633974483, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertFalse(complex12.isInfinite());
assertEquals(0.7853981633974483, complex12.getReal(), 0.01);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
Complex complex14 = complex10.cos();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex10));
assertTrue(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex3));
assertTrue(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex13));
assertNotNull(complex14);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.5403023058681398, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.7853981633974483, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex10.isInfinite());
assertEquals(1.0, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(-0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex13);
}
@Test(timeout = 4000)
public void test080() throws Throwable {
Complex complex0 = Complex.NaN;
assertNotNull(complex0);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
Complex complex1 = complex0.atan();
assertNotNull(complex1);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertSame(complex0, complex1);
assertSame(complex1, complex0);
Complex complex2 = complex0.I.acos();
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.I.tan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(0.7615941559557649, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex3.ZERO.pow(6.283185307179586);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(0.7615941559557649, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
Complex complex5 = complex4.INF.log();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(0.7615941559557649, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex5.getReal(), 0.01);
assertEquals(0.7853981633974483, complex5.getImaginary(), 0.01);
assertTrue(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex3);
assertSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
Complex complex6 = complex2.ONE.add(0.0);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
Complex complex7 = complex1.add(complex0);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex4));
assertNotNull(complex7);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertSame(complex1, complex0);
assertSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertSame(complex7, complex0);
Complex complex8 = complex7.ONE.multiply((-607));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex8);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals((-607.0), complex8.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertSame(complex1, complex0);
assertSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex8);
assertSame(complex7, complex0);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
List<Complex> list0 = complex1.nthRoot(103);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex4));
assertNotNull(list0);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1, list0.size());
assertFalse(list0.isEmpty());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertSame(complex1, complex0);
assertSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertFalse(list0.contains(complex3));
assertTrue(list0.contains(complex7));
Complex complex9 = complex8.subtract(complex0);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex8));
assertTrue(complex7.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex4));
assertNotNull(complex9);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertEquals((-607.0), complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex8);
assertSame(complex1, complex0);
assertSame(complex1, complex7);
assertSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertSame(complex7, complex1);
assertSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex8);
assertSame(complex7, complex0);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertSame(complex9, complex7);
assertSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
Complex complex10 = complex6.INF.asin();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex3));
assertNotNull(complex10);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertSame(complex0, complex1);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex8);
assertSame(complex10, complex7);
assertSame(complex10, complex9);
assertSame(complex10, complex1);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex4);
assertSame(complex10, complex0);
assertNotSame(complex10, complex3);
Complex complex11 = complex10.NaN.cosh();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertTrue(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertNotNull(complex11);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertSame(complex0, complex1);
assertSame(complex0, complex10);
assertSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex8);
assertSame(complex10, complex7);
assertSame(complex10, complex9);
assertSame(complex10, complex1);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex2);
assertSame(complex10, complex11);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex4);
assertSame(complex10, complex0);
assertNotSame(complex10, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertSame(complex11, complex9);
assertNotSame(complex11, complex8);
assertSame(complex11, complex1);
assertSame(complex11, complex10);
assertNotSame(complex11, complex3);
assertSame(complex11, complex7);
boolean boolean0 = complex2.isNaN();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(boolean0);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertSame(complex0, complex1);
assertSame(complex0, complex10);
assertSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
Complex complex12 = complex6.add(2.6015626820520968E-9);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex0));
assertNotNull(complex12);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(1.0000000026015627, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex0, complex6);
assertSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertSame(complex0, complex11);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex8);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex0);
Complex complex13 = complex12.exp();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex8));
assertNotNull(complex13);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(1.0000000026015627, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(2.718281835530826, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex13);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex11);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex8);
Complex complex14 = complex12.ZERO.sin();
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(complex14);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(1.0000000026015627, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex12);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex13);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex11);
String string0 = complex7.toString();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex8));
assertTrue(complex7.equals((Object)complex4));
assertEquals("(NaN, NaN)", string0);
assertNotNull(string0);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex12);
assertSame(complex1, complex7);
assertSame(complex1, complex10);
assertSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertSame(complex7, complex9);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex6);
assertSame(complex7, complex0);
assertNotSame(complex7, complex8);
assertSame(complex7, complex1);
assertNotSame(complex7, complex13);
assertSame(complex7, complex11);
assertNotSame(complex7, complex4);
assertSame(complex7, complex10);
ComplexField complexField0 = complex12.getField();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(complexField0);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(1.0000000026015627, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex13);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex11);
Complex complex15 = Complex.valueOf(2.0, (double) 103);
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertNotNull(complex15);
assertEquals(2.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(103.0, complex15.getImaginary(), 0.01);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex6);
Complex complex16 = complex1.pow(2.0);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex4));
assertTrue(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex15));
assertNotNull(complex16);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertTrue(complex16.isNaN());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex15);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex3);
assertSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex14);
assertSame(complex1, complex16);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex12);
assertSame(complex1, complex7);
assertSame(complex1, complex10);
assertSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertSame(complex16, complex0);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex2);
assertSame(complex16, complex11);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex8);
assertSame(complex16, complex9);
assertSame(complex16, complex7);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex15);
assertSame(complex16, complex1);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex13);
assertSame(complex16, complex10);
Complex complex17 = complex16.multiply((-607));
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex4));
assertTrue(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex6));
assertTrue(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex15));
assertNotNull(complex17);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertTrue(complex16.isNaN());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertEquals(Double.NaN, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertTrue(complex17.isNaN());
assertEquals(Double.NaN, complex17.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertSame(complex1, complex11);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex3);
assertSame(complex1, complex0);
assertNotSame(complex1, complex8);
assertSame(complex1, complex17);
assertNotSame(complex1, complex14);
assertSame(complex1, complex16);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex12);
assertSame(complex1, complex7);
assertSame(complex1, complex10);
assertSame(complex1, complex9);
assertNotSame(complex1, complex4);
assertSame(complex16, complex0);
assertSame(complex16, complex17);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex2);
assertSame(complex16, complex11);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex8);
assertSame(complex16, complex9);
assertSame(complex16, complex7);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex15);
assertSame(complex16, complex1);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex13);
assertSame(complex16, complex10);
assertSame(complex17, complex10);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex14);
assertSame(complex17, complex9);
assertSame(complex17, complex16);
assertNotSame(complex17, complex8);
assertSame(complex17, complex1);
assertNotSame(complex17, complex15);
assertSame(complex17, complex7);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex12);
assertSame(complex17, complex0);
assertSame(complex17, complex11);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex13);
Complex complex18 = complex13.multiply(1);
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex15));
assertTrue(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex8));
assertNotNull(complex18);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertEquals(2.718281835530826, complex18.getReal(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(1.0, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertEquals(1.0000000026015627, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(2.718281835530826, complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex17);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex18);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex17);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex16);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex17);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex18);
assertNotSame(complex12, complex11);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex18);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex8);
String string1 = complex4.toString();
assertTrue(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex12));
assertTrue(complex4.equals((Object)complex10));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex9));
assertTrue(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex15));
assertTrue(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex2));
assertTrue(complex4.equals((Object)complex11));
assertTrue(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex13));
assertTrue(string1.equals((Object)string0));
assertEquals("(NaN, NaN)", string1);
assertNotNull(string1);
assertEquals(Double.NaN, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex0.isNaN());
assertEquals(Double.NaN, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals((-0.8813735870195429), complex2.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex2.getReal(), 0.01);
assertEquals(0.7615941559557649, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertSame(complex0, complex10);
assertSame(complex0, complex16);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertSame(complex0, complex17);
assertNotSame(complex0, complex15);
assertSame(complex0, complex7);
assertSame(complex0, complex11);
assertNotSame(complex0, complex14);
assertSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex10);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex16);
}
@Test(timeout = 4000)
public void test081() throws Throwable {
Complex complex0 = Complex.valueOf((-2438.256513));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.multiply((-2438.256513));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
Complex complex4 = complex1.NaN.pow(complex0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
Complex complex5 = complex4.NaN.negate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex4, complex1);
assertSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex1);
assertSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex2);
Complex complex6 = complex1.sqrt1z();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
Complex complex7 = complex6.I.atan();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex7, complex0);
assertSame(complex7, complex5);
assertSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
Complex complex8 = complex1.NaN.add(complex7);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex1));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertTrue(complex8.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex7, complex0);
assertSame(complex7, complex5);
assertSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex8, complex6);
assertSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex1);
assertSame(complex8, complex4);
assertSame(complex8, complex7);
Complex complex9 = complex6.ZERO.log();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
Complex complex10 = complex0.multiply(complex6);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals((-20832.204028784934), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-7613.650176966752), complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
Complex complex11 = complex6.I.add(complex3);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex8);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
Complex complex12 = complex1.subtract(complex3);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex3));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(5945094.823186918, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals((-5945091.681594265), complex12.getReal(), 0.01);
assertEquals((-8.492185657535124), complex12.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex8);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex3);
double double0 = complex9.getImaginary();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex11));
assertEquals(0.0, double0, 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertTrue(complex9.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex11);
Complex complex13 = Complex.NaN;
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex6));
assertNotNull(complex13);
assertFalse(complex13.isInfinite());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertTrue(complex13.isNaN());
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex3);
assertSame(complex13, complex4);
assertNotSame(complex13, complex9);
assertSame(complex13, complex5);
assertSame(complex13, complex7);
assertSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex6);
boolean boolean0 = complex10.equals(complex13);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex6));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals((-20832.204028784934), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-7613.650176966752), complex10.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertTrue(complex13.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex5);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex3);
assertSame(complex13, complex4);
assertNotSame(complex13, complex9);
assertSame(complex13, complex5);
assertSame(complex13, complex7);
assertSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex6);
Complex complex14 = complex2.sinh();
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex14);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(1.1768576043096548, complex14.getReal(), 0.01);
assertEquals(0.005525782205542805, complex14.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1.0010778834778606, complex2.getReal(), 0.01);
assertEquals(0.003578075058834327, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex1);
Complex complex15 = complex6.asin();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex15);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(2.898739386328194, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(1.218440655622155, complex15.getReal(), 0.01);
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex6);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex5);
Complex complex16 = complex0.createComplex(406.429142882207, (-3116.1863041));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex16.isNaN());
assertEquals(406.429142882207, complex16.getReal(), 0.01);
assertEquals((-3116.1863041), complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex10);
Complex complex17 = complex6.conjugate();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex17.isNaN());
assertEquals((-3.1225796532781587), complex17.getImaginary(), 0.01);
assertEquals(8.543893522980179, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex17);
String string0 = complex10.toString();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex3));
assertEquals("(-20832.204028784934, -7613.650176966752)", string0);
assertNotNull(string0);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertEquals((-20832.204028784934), complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-7613.650176966752), complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex17);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex3);
Complex complex18 = complex1.pow(complex8);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex12));
assertNotNull(complex18);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(3.1225796532781587, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(8.543893522980179, complex6.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertTrue(complex8.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertSame(complex18, complex4);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex2);
assertSame(complex18, complex8);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex10);
assertSame(complex18, complex7);
assertSame(complex18, complex5);
assertSame(complex18, complex13);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex9);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex18);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex17);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex14);
assertSame(complex7, complex13);
assertNotSame(complex7, complex1);
assertSame(complex7, complex18);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex17);
assertSame(complex7, complex5);
assertSame(complex7, complex4);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertSame(complex7, complex8);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex17);
assertSame(complex8, complex13);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex14);
assertSame(complex8, complex18);
assertSame(complex8, complex4);
assertSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertSame(complex8, complex5);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex12);
double double1 = complex0.abs();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertNotEquals(double1, double0, 0.01);
assertEquals(2438.256513, double1, 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
Complex complex19 = complex1.subtract(2428.509);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex16));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertEquals((-2438.256513), complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals((-8.492185657535124), complex1.getImaginary(), 0.01);
assertEquals(3.141592653589793, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-8.492185657535124), complex19.getImaginary(), 0.01);
assertEquals((-2425.3674073464103), complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertFalse(complex19.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex19);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex9);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex16);
}
@Test(timeout = 4000)
public void test082() throws Throwable {
Complex complex0 = new Complex(567.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
boolean boolean0 = complex0.isNaN();
assertFalse(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
complex0.hashCode();
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.atan();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
boolean boolean1 = complex1.isInfinite();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.ONE.divide(969.6083);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.001031344306768001, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.pow(6.283185307179586);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
double double0 = complex3.getArgument();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex0.subtract(complex3);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-2.00111762808260032E17), complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
Complex complex5 = complex4.NaN.conjugate();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex4.isInfinite());
assertEquals((-2.00111762808260032E17), complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertTrue(complex5.isNaN());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
Complex complex6 = complex2.atan();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.001031344306768001, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1102230246251564E-16, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0010313439410978638, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
Complex complex7 = complex6.INF.exp();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.001031344306768001, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1102230246251564E-16, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0010313439410978638, complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
Complex complex8 = complex3.ZERO.sinh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex7));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals(0.0, complex8.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex7);
Complex complex9 = Complex.valueOf((-2600.2125749643837), (-2195.96254837));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertNotNull(complex9);
assertEquals((-2195.96254837), complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals((-2600.2125749643837), complex9.getReal(), 0.01);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
Complex complex10 = complex1.add(0.0);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(1.5690326601932039, complex10.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
Complex complex11 = complex0.I.subtract((-943.16665497506));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex9));
assertNotNull(complex11);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(943.16665497506, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex9);
Complex complex12 = complex0.INF.subtract(complex10);
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex2));
assertNotNull(complex12);
assertTrue(complex12.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex12.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(1.5690326601932039, complex10.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex1);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
Complex complex13 = complex2.sin();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex11));
assertNotNull(complex13);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertEquals(0.0010313441239328254, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.001031344306768001, complex2.getReal(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex3);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
Complex complex14 = complex3.exp();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertTrue(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertNotNull(complex14);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertEquals(Double.NaN, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertTrue(complex14.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex10);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
Complex complex15 = complex10.reciprocal();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex14));
assertNotNull(complex15);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.6373353629725365, complex15.getReal(), 0.01);
assertEquals(4.5096855682584234E-17, complex15.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(1.5690326601932039, complex10.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex13);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex14);
Complex complex16 = complex15.INF.divide(complex14);
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex13));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex6));
assertTrue(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex3));
assertTrue(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex4));
assertTrue(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex14));
assertNotNull(complex16);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertEquals(Double.NaN, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertTrue(complex14.isNaN());
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.6373353629725365, complex15.getReal(), 0.01);
assertEquals(4.5096855682584234E-17, complex15.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex16.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertTrue(complex16.isNaN());
assertEquals(Double.NaN, complex16.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex10.isInfinite());
assertEquals(1.5690326601932039, complex10.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex10);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex13);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex11);
assertSame(complex16, complex5);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex1);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex15);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex14);
Complex complex17 = complex15.ZERO.sqrt1z();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex14));
assertNotNull(complex17);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.6373353629725365, complex15.getReal(), 0.01);
assertEquals(4.5096855682584234E-17, complex15.getImaginary(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(1.0, complex17.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(1.5690326601932039, complex10.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex13);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex10);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex14);
Complex complex18 = complex10.log();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex0));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex14));
assertNotNull(complex18);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.5690326601932039, complex1.getReal(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals((-7.075843943799414E-17), complex18.getImaginary(), 0.01);
assertEquals(0.45045928946363134, complex18.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(1.5690326601932039, complex10.getReal(), 0.01);
assertEquals((-1.1102230246251565E-16), complex10.getImaginary(), 0.01);
assertFalse(complex10.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex13);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex10);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex18);
assertNotSame(complex10, complex12);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex16);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex14);
Complex complex19 = complex9.atan();
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex18));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex19);
assertFalse(complex19.isNaN());
assertEquals((-1.5705718484648041), complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals((-1.8957910679257947E-4), complex19.getImaginary(), 0.01);
assertEquals((-2195.96254837), complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals((-2600.2125749643837), complex9.getReal(), 0.01);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex18);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex19);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex17);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex18);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
Complex complex20 = complex19.NaN.cosh();
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex10));
assertTrue(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex4));
assertTrue(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex19));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex18));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex20);
assertFalse(complex19.isNaN());
assertEquals((-1.5705718484648041), complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals((-1.8957910679257947E-4), complex19.getImaginary(), 0.01);
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertTrue(complex20.isNaN());
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals((-2195.96254837), complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals((-2600.2125749643837), complex9.getReal(), 0.01);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex20);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex18);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex1);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex18);
assertSame(complex20, complex16);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex4);
assertSame(complex20, complex5);
assertNotSame(complex20, complex12);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex19);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex17);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex20);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex18);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
Complex complex21 = complex3.log();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex15));
assertNotNull(complex21);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
assertEquals(39.8376524194216, complex21.getReal(), 0.01);
assertEquals(0.0, complex21.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex20);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex20);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex21);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex19);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex15);
assertNotSame(complex21, complex13);
assertNotSame(complex21, complex18);
assertNotSame(complex21, complex11);
assertNotSame(complex21, complex8);
assertNotSame(complex21, complex3);
assertNotSame(complex21, complex20);
assertNotSame(complex21, complex4);
assertNotSame(complex21, complex7);
assertNotSame(complex21, complex2);
assertNotSame(complex21, complex16);
assertNotSame(complex21, complex12);
assertNotSame(complex21, complex10);
assertNotSame(complex21, complex14);
assertNotSame(complex21, complex1);
assertNotSame(complex21, complex0);
assertNotSame(complex21, complex5);
assertNotSame(complex21, complex19);
assertNotSame(complex21, complex17);
assertNotSame(complex21, complex6);
assertNotSame(complex21, complex9);
assertNotSame(complex21, complex15);
Complex complex22 = Complex.valueOf((-2600.2125749643837));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex15));
assertNotNull(complex22);
assertFalse(complex22.isInfinite());
assertFalse(complex22.isNaN());
assertEquals((-2600.2125749643837), complex22.getReal(), 0.01);
assertEquals(0.0, complex22.getImaginary(), 0.01);
assertNotSame(complex22, complex19);
assertNotSame(complex22, complex6);
assertNotSame(complex22, complex17);
assertNotSame(complex22, complex5);
assertNotSame(complex22, complex2);
assertNotSame(complex22, complex18);
assertNotSame(complex22, complex11);
assertNotSame(complex22, complex12);
assertNotSame(complex22, complex10);
assertNotSame(complex22, complex0);
assertNotSame(complex22, complex3);
assertNotSame(complex22, complex20);
assertNotSame(complex22, complex16);
assertNotSame(complex22, complex1);
assertNotSame(complex22, complex21);
assertNotSame(complex22, complex4);
assertNotSame(complex22, complex7);
assertNotSame(complex22, complex8);
assertNotSame(complex22, complex13);
assertNotSame(complex22, complex14);
assertNotSame(complex22, complex9);
assertNotSame(complex22, complex15);
complex3.hashCode();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex21));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex22));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex15));
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(567.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(2.00111762808260608E17, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex22);
assertNotSame(complex0, complex21);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex20);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex20);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex21);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex22);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex19);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex15);
Complex complex23 = Complex.valueOf(941.3757229489925);
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex21));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex13));
assertNotNull(complex23);
assertEquals(0.0, complex23.getImaginary(), 0.01);
assertFalse(complex23.isNaN());
assertEquals(941.3757229489925, complex23.getReal(), 0.01);
assertFalse(complex23.isInfinite());
assertNotSame(complex23, complex11);
assertNotSame(complex23, complex16);
assertNotSame(complex23, complex17);
assertNotSame(complex23, complex19);
assertNotSame(complex23, complex18);
assertNotSame(complex23, complex6);
assertNotSame(complex23, complex2);
assertNotSame(complex23, complex20);
assertNotSame(complex23, complex0);
assertNotSame(complex23, complex3);
assertNotSame(complex23, complex5);
assertNotSame(complex23, complex8);
assertNotSame(complex23, complex22);
assertNotSame(complex23, complex10);
assertNotSame(complex23, complex1);
assertNotSame(complex23, complex7);
assertNotSame(complex23, complex12);
assertNotSame(complex23, complex21);
assertNotSame(complex23, complex14);
assertNotSame(complex23, complex15);
assertNotSame(complex23, complex4);
assertNotSame(complex23, complex9);
assertNotSame(complex23, complex13);
}
@Test(timeout = 4000)
public void test083() throws Throwable {
Complex complex0 = Complex.INF;
assertNotNull(complex0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
Complex complex1 = complex0.ONE.subtract((-7.40238661307607E-8));
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0000000740238661, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.INF.divide(0.0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0000000740238661, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex1.NaN.sin();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0000000740238661, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex3, complex0);
assertSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex0.ZERO.acos();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex0.INF.sqrt1z();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
Complex complex6 = complex4.ONE.negate();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
Complex complex7 = complex6.add(complex3);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertNotNull(complex7);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0000000740238661, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals((-1.0), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex6);
assertSame(complex3, complex7);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertSame(complex7, complex2);
assertSame(complex7, complex3);
Complex complex8 = complex5.ONE.sqrt();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertNotNull(complex8);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(1.0, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex8);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
Complex complex9 = complex5.I.exp();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex9);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.5403023058681398, complex9.getReal(), 0.01);
assertEquals(0.8414709848078965, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex3);
Complex complex10 = Complex.NaN;
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertTrue(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex0));
assertNotNull(complex10);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertSame(complex10, complex7);
assertSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex0);
assertSame(complex10, complex2);
Complex complex11 = complex5.add(complex10);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertTrue(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertTrue(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertNotNull(complex11);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
Complex complex12 = complex9.divide(complex0);
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertTrue(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertNotNull(complex12);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.5403023058681398, complex9.getReal(), 0.01);
assertEquals(0.8414709848078965, complex9.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
String string0 = complex0.ZERO.toString();
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertEquals("(0.0, 0.0)", string0);
assertNotNull(string0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
Complex complex13 = Complex.valueOf((-3355.131), (-7.40238661307607E-8));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex12));
assertNotNull(complex13);
assertFalse(complex13.isNaN());
assertEquals((-7.40238661307607E-8), complex13.getImaginary(), 0.01);
assertEquals((-3355.131), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
Complex complex14 = complex13.ZERO.subtract(0.0);
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex12));
assertNotNull(complex14);
assertFalse(complex13.isNaN());
assertEquals((-7.40238661307607E-8), complex13.getImaginary(), 0.01);
assertEquals((-3355.131), complex13.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertEquals(0.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
Complex complex15 = (Complex)complex0.readResolve();
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex4));
assertTrue(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertNotNull(complex15);
assertEquals(Double.POSITIVE_INFINITY, complex15.getReal(), 0.01);
assertFalse(complex15.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex15.getImaginary(), 0.01);
assertTrue(complex15.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
Complex complex16 = complex4.cos();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertNotNull(complex16);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
Complex complex17 = complex16.ONE.negate();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex10));
assertTrue(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertNotNull(complex17);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertEquals((-1.0), complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertEquals(-0.0, complex17.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
Complex complex18 = complex16.NaN.cosh();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex16));
assertTrue(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertNotNull(complex18);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
Complex complex19 = complex18.cos();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex16));
assertTrue(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex13));
assertTrue(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertNotNull(complex19);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertEquals(Double.NaN, complex19.getReal(), 0.01);
assertEquals(Double.NaN, complex19.getImaginary(), 0.01);
assertFalse(complex19.isInfinite());
assertTrue(complex19.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
boolean boolean0 = complex8.isNaN();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertTrue(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex7));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex12));
assertTrue(complex5.equals((Object)complex19));
assertFalse(complex5.equals((Object)complex16));
assertTrue(complex5.equals((Object)complex10));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex18));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex19));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex15));
assertFalse(boolean0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(1.0, complex8.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
Complex complex20 = complex16.sinh();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex8));
assertNotNull(complex20);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(6.123233995736766E-17, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
Complex complex21 = complex20.I.sin();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex11));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex3));
assertNotNull(complex21);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(6.123233995736766E-17, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertFalse(complex21.isNaN());
assertEquals(0.0, complex21.getReal(), 0.01);
assertEquals(1.1752011936438014, complex21.getImaginary(), 0.01);
Complex complex22 = complex20.I.subtract(0.0);
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex21));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex4));
assertNotNull(complex22);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(6.123233995736766E-17, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertEquals(1.0, complex22.getImaginary(), 0.01);
assertFalse(complex22.isNaN());
assertEquals(0.0, complex22.getReal(), 0.01);
assertFalse(complex22.isInfinite());
Complex complex23 = complex16.ONE.sqrt();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex21));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex22));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex22));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex3));
assertFalse(complex23.equals((Object)complex12));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex0));
assertTrue(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex14));
assertFalse(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex11));
assertFalse(complex23.equals((Object)complex22));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex10));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex19));
assertFalse(complex23.equals((Object)complex2));
assertFalse(complex23.equals((Object)complex16));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex1));
assertFalse(complex23.equals((Object)complex21));
assertNotNull(complex23);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertEquals(1.0, complex23.getReal(), 0.01);
assertEquals(0.0, complex23.getImaginary(), 0.01);
assertFalse(complex23.isNaN());
assertFalse(complex23.isInfinite());
Complex complex24 = complex2.log();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex23));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex21));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex16));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex22));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex23));
assertFalse(complex2.equals((Object)complex20));
assertFalse(complex2.equals((Object)complex13));
assertTrue(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex22));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex22));
assertFalse(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex21));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex1));
assertFalse(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex20));
assertFalse(complex24.equals((Object)complex12));
assertFalse(complex24.equals((Object)complex17));
assertTrue(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex23));
assertNotNull(complex24);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(1.0000000740238661, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex24.getImaginary(), 0.01);
assertFalse(complex24.isInfinite());
assertTrue(complex24.isNaN());
assertEquals(Double.NaN, complex24.getReal(), 0.01);
String string1 = complex16.ONE.toString();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex21));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex23));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex24));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex22));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex23));
assertFalse(complex4.equals((Object)complex24));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex22));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex18));
assertFalse(string1.equals((Object)string0));
assertEquals("(1.0, 0.0)", string1);
assertNotNull(string1);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
Complex complex25 = complex0.INF.tan();
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex25.equals((Object)complex12));
assertFalse(complex25.equals((Object)complex16));
assertFalse(complex25.equals((Object)complex6));
assertFalse(complex25.equals((Object)complex4));
assertFalse(complex25.equals((Object)complex1));
assertFalse(complex25.equals((Object)complex21));
assertFalse(complex25.equals((Object)complex23));
assertFalse(complex25.equals((Object)complex13));
assertFalse(complex25.equals((Object)complex17));
assertTrue(complex25.equals((Object)complex5));
assertFalse(complex25.equals((Object)complex9));
assertFalse(complex25.equals((Object)complex0));
assertFalse(complex25.equals((Object)complex22));
assertFalse(complex25.equals((Object)complex15));
assertFalse(complex25.equals((Object)complex8));
assertFalse(complex25.equals((Object)complex20));
assertFalse(complex25.equals((Object)complex14));
assertNotNull(complex25);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.NaN, complex25.getReal(), 0.01);
assertEquals(Double.NaN, complex25.getImaginary(), 0.01);
assertFalse(complex25.isInfinite());
assertTrue(complex25.isNaN());
Complex complex26 = complex25.ZERO.sin();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex25));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex25.equals((Object)complex12));
assertFalse(complex25.equals((Object)complex16));
assertFalse(complex25.equals((Object)complex6));
assertFalse(complex25.equals((Object)complex4));
assertFalse(complex25.equals((Object)complex1));
assertFalse(complex25.equals((Object)complex21));
assertFalse(complex25.equals((Object)complex23));
assertFalse(complex25.equals((Object)complex13));
assertFalse(complex25.equals((Object)complex17));
assertTrue(complex25.equals((Object)complex5));
assertFalse(complex25.equals((Object)complex9));
assertFalse(complex25.equals((Object)complex0));
assertFalse(complex25.equals((Object)complex22));
assertFalse(complex25.equals((Object)complex15));
assertFalse(complex25.equals((Object)complex8));
assertFalse(complex25.equals((Object)complex20));
assertFalse(complex25.equals((Object)complex14));
assertFalse(complex26.equals((Object)complex2));
assertFalse(complex26.equals((Object)complex0));
assertFalse(complex26.equals((Object)complex17));
assertTrue(complex26.equals((Object)complex12));
assertFalse(complex26.equals((Object)complex5));
assertFalse(complex26.equals((Object)complex8));
assertFalse(complex26.equals((Object)complex22));
assertFalse(complex26.equals((Object)complex10));
assertFalse(complex26.equals((Object)complex25));
assertFalse(complex26.equals((Object)complex6));
assertFalse(complex26.equals((Object)complex18));
assertFalse(complex26.equals((Object)complex19));
assertFalse(complex26.equals((Object)complex24));
assertFalse(complex26.equals((Object)complex4));
assertFalse(complex26.equals((Object)complex3));
assertFalse(complex26.equals((Object)complex23));
assertFalse(complex26.equals((Object)complex13));
assertFalse(complex26.equals((Object)complex7));
assertTrue(complex26.equals((Object)complex14));
assertFalse(complex26.equals((Object)complex9));
assertFalse(complex26.equals((Object)complex1));
assertFalse(complex26.equals((Object)complex15));
assertFalse(complex26.equals((Object)complex20));
assertFalse(complex26.equals((Object)complex11));
assertFalse(complex26.equals((Object)complex21));
assertFalse(complex26.equals((Object)complex16));
assertNotNull(complex26);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(Double.NaN, complex25.getReal(), 0.01);
assertEquals(Double.NaN, complex25.getImaginary(), 0.01);
assertFalse(complex25.isInfinite());
assertTrue(complex25.isNaN());
assertEquals(0.0, complex26.getImaginary(), 0.01);
assertFalse(complex26.isNaN());
assertEquals(0.0, complex26.getReal(), 0.01);
assertFalse(complex26.isInfinite());
Complex complex27 = complex22.divide(complex20);
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex25));
assertFalse(complex0.equals((Object)complex26));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex21));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex23));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex26));
assertFalse(complex16.equals((Object)complex24));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex22));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex25));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex22));
assertFalse(complex4.equals((Object)complex25));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex23));
assertFalse(complex4.equals((Object)complex24));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex26));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex22));
assertFalse(complex20.equals((Object)complex26));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex24));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex23));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex25));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex24));
assertFalse(complex22.equals((Object)complex26));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex23));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex25));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex27.equals((Object)complex26));
assertFalse(complex27.equals((Object)complex19));
assertFalse(complex27.equals((Object)complex13));
assertFalse(complex27.equals((Object)complex24));
assertFalse(complex27.equals((Object)complex23));
assertFalse(complex27.equals((Object)complex6));
assertFalse(complex27.equals((Object)complex18));
assertFalse(complex27.equals((Object)complex25));
assertFalse(complex27.equals((Object)complex8));
assertFalse(complex27.equals((Object)complex0));
assertFalse(complex27.equals((Object)complex7));
assertFalse(complex27.equals((Object)complex22));
assertFalse(complex27.equals((Object)complex4));
assertFalse(complex27.equals((Object)complex2));
assertFalse(complex27.equals((Object)complex15));
assertFalse(complex27.equals((Object)complex5));
assertFalse(complex27.equals((Object)complex10));
assertFalse(complex27.equals((Object)complex20));
assertFalse(complex27.equals((Object)complex12));
assertFalse(complex27.equals((Object)complex14));
assertFalse(complex27.equals((Object)complex11));
assertFalse(complex27.equals((Object)complex9));
assertFalse(complex27.equals((Object)complex16));
assertFalse(complex27.equals((Object)complex17));
assertFalse(complex27.equals((Object)complex3));
assertFalse(complex27.equals((Object)complex21));
assertFalse(complex27.equals((Object)complex1));
assertNotNull(complex27);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(6.123233995736766E-17, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertEquals(1.0, complex22.getImaginary(), 0.01);
assertFalse(complex22.isNaN());
assertEquals(0.0, complex22.getReal(), 0.01);
assertFalse(complex22.isInfinite());
assertEquals(0.0, complex27.getReal(), 0.01);
assertFalse(complex27.isNaN());
assertEquals(1.633123935319537E16, complex27.getImaginary(), 0.01);
assertFalse(complex27.isInfinite());
Complex complex28 = complex20.cos();
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex25));
assertFalse(complex0.equals((Object)complex26));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex27));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex27));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex21));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex23));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex26));
assertFalse(complex16.equals((Object)complex24));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex22));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex25));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex22));
assertFalse(complex4.equals((Object)complex25));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex23));
assertFalse(complex4.equals((Object)complex24));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex27));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex26));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex27));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex22));
assertFalse(complex20.equals((Object)complex26));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex24));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex23));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex25));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex16));
assertFalse(complex28.equals((Object)complex7));
assertFalse(complex28.equals((Object)complex13));
assertFalse(complex28.equals((Object)complex3));
assertFalse(complex28.equals((Object)complex21));
assertFalse(complex28.equals((Object)complex19));
assertFalse(complex28.equals((Object)complex14));
assertFalse(complex28.equals((Object)complex26));
assertFalse(complex28.equals((Object)complex24));
assertFalse(complex28.equals((Object)complex25));
assertFalse(complex28.equals((Object)complex6));
assertFalse(complex28.equals((Object)complex10));
assertFalse(complex28.equals((Object)complex22));
assertFalse(complex28.equals((Object)complex0));
assertFalse(complex28.equals((Object)complex5));
assertFalse(complex28.equals((Object)complex17));
assertFalse(complex28.equals((Object)complex16));
assertFalse(complex28.equals((Object)complex12));
assertFalse(complex28.equals((Object)complex2));
assertFalse(complex28.equals((Object)complex4));
assertTrue(complex28.equals((Object)complex8));
assertFalse(complex28.equals((Object)complex20));
assertFalse(complex28.equals((Object)complex18));
assertFalse(complex28.equals((Object)complex9));
assertFalse(complex28.equals((Object)complex11));
assertFalse(complex28.equals((Object)complex1));
assertFalse(complex28.equals((Object)complex15));
assertFalse(complex28.equals((Object)complex27));
assertTrue(complex28.equals((Object)complex23));
assertNotNull(complex28);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(6.123233995736766E-17, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex28.isNaN());
assertEquals(1.0, complex28.getReal(), 0.01);
assertFalse(complex28.isInfinite());
assertEquals(-0.0, complex28.getImaginary(), 0.01);
Complex complex29 = complex22.divide((-3355.131));
assertFalse(complex29.equals((Object)complex26));
assertFalse(complex29.equals((Object)complex19));
assertFalse(complex29.equals((Object)complex24));
assertFalse(complex29.equals((Object)complex7));
assertFalse(complex29.equals((Object)complex13));
assertFalse(complex29.equals((Object)complex3));
assertFalse(complex29.equals((Object)complex6));
assertFalse(complex29.equals((Object)complex1));
assertFalse(complex29.equals((Object)complex18));
assertFalse(complex29.equals((Object)complex27));
assertFalse(complex29.equals((Object)complex8));
assertFalse(complex29.equals((Object)complex9));
assertFalse(complex29.equals((Object)complex5));
assertFalse(complex29.equals((Object)complex28));
assertFalse(complex29.equals((Object)complex23));
assertFalse(complex29.equals((Object)complex10));
assertFalse(complex29.equals((Object)complex22));
assertFalse(complex29.equals((Object)complex20));
assertFalse(complex29.equals((Object)complex4));
assertFalse(complex29.equals((Object)complex25));
assertFalse(complex29.equals((Object)complex17));
assertFalse(complex29.equals((Object)complex11));
assertFalse(complex29.equals((Object)complex16));
assertFalse(complex29.equals((Object)complex15));
assertFalse(complex29.equals((Object)complex2));
assertFalse(complex29.equals((Object)complex21));
assertFalse(complex29.equals((Object)complex0));
assertFalse(complex29.equals((Object)complex14));
assertFalse(complex29.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex28));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex25));
assertFalse(complex0.equals((Object)complex26));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex27));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex27));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex18));
assertFalse(complex16.equals((Object)complex28));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex17));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex21));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex23));
assertTrue(complex16.equals((Object)complex20));
assertFalse(complex16.equals((Object)complex26));
assertFalse(complex16.equals((Object)complex24));
assertFalse(complex16.equals((Object)complex19));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex22));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex25));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex20));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex28));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex22));
assertFalse(complex4.equals((Object)complex25));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex23));
assertFalse(complex4.equals((Object)complex24));
assertFalse(complex4.equals((Object)complex19));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex21));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex27));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex26));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex28));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex27));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex22));
assertFalse(complex20.equals((Object)complex26));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex24));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex23));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex25));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex11));
assertTrue(complex20.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex24));
assertFalse(complex22.equals((Object)complex26));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex23));
assertFalse(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex25));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex10));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex28));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex27));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex17));
assertNotNull(complex29);
assertFalse(complex29.isInfinite());
assertFalse(complex29.isNaN());
assertEquals((-2.9805095538743497E-4), complex29.getImaginary(), 0.01);
assertEquals(-0.0, complex29.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(6.123233995736766E-17, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(-0.0, complex4.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex4.getReal(), 0.01);
assertFalse(complex20.isInfinite());
assertEquals(6.123233995736766E-17, complex20.getReal(), 0.01);
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertEquals(1.0, complex22.getImaginary(), 0.01);
assertFalse(complex22.isNaN());
assertEquals(0.0, complex22.getReal(), 0.01);
assertFalse(complex22.isInfinite());
List<Complex> list0 = complex12.nthRoot(1161);
assertFalse(complex0.equals((Object)complex28));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex29));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex25));
assertFalse(complex0.equals((Object)complex26));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex27));
assertFalse(complex5.equals((Object)complex27));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex29));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex9));
assertTrue(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex20));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex21));
assertTrue(complex5.equals((Object)complex25));
assertTrue(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex22));
assertFalse(complex5.equals((Object)complex23));
assertTrue(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex26));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex28));
assertTrue(complex5.equals((Object)complex24));
assertTrue(complex5.equals((Object)complex19));
assertTrue(complex5.equals((Object)complex10));
assertTrue(complex5.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex22));
assertFalse(complex9.equals((Object)complex25));
assertFalse(complex9.equals((Object)complex21));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex24));
assertFalse(complex9.equals((Object)complex28));
assertFalse(complex9.equals((Object)complex26));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex9.equals((Object)complex23));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex27));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex29));
assertFalse(complex9.equals((Object)complex18));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex19));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex20));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex29));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex27));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertTrue(complex12.equals((Object)complex26));
assertFalse(complex12.equals((Object)complex22));
assertFalse(complex12.equals((Object)complex28));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex24));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex18));
assertTrue(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex23));
assertFalse(complex12.equals((Object)complex21));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex25));
assertFalse(complex12.equals((Object)complex20));
assertFalse(complex12.equals((Object)complex11));
assertNotNull(list0);
assertEquals(Double.POSITIVE_INFINITY, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex0.isInfinite());
assertEquals(1161, list0.size());
assertFalse(list0.isEmpty());
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertEquals(Double.NEGATIVE_INFINITY, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(0.5403023058681398, complex9.getReal(), 0.01);
assertEquals(0.8414709848078965, complex9.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertFalse(complex12.isNaN());
}
@Test(timeout = 4000)
public void test084() throws Throwable {
Complex complex0 = new Complex(0.0, 0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.INF.cos();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.INF.reciprocal();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.multiply((-1.1487079818684332E-8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-1.8043862784789136E-8), complex4.getReal(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
Complex complex5 = complex3.I.cosh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
Complex complex6 = complex5.INF.add(complex1);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.5707963267948966, complex1.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertEquals(0.5403023058681398, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex6.getReal(), 0.01);
assertTrue(complex6.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
Complex complex7 = complex0.ZERO.cos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
Complex complex8 = complex0.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex3);
Complex complex9 = complex8.ZERO.reciprocal();
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
Complex complex10 = complex9.asin();
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertSame(complex9, complex10);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertSame(complex10, complex9);
Complex complex11 = complex8.INF.multiply(0.0);
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex10));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertTrue(complex11.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex10);
Complex complex12 = complex11.ZERO.pow(complex10);
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex6));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex1));
assertTrue(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex0));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex11.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex12);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertSame(complex9, complex10);
assertNotSame(complex9, complex2);
assertSame(complex9, complex12);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertSame(complex10, complex12);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertSame(complex10, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex11);
assertSame(complex12, complex9);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex4);
assertSame(complex12, complex10);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex0);
double double0 = complex0.ONE.getArgument();
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertEquals(0.0, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
double double1 = complex8.abs();
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex12));
assertEquals(double1, double0, 0.01);
assertEquals(0.0, double1, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex12);
Complex complex13 = complex7.exp();
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex13);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
Complex complex14 = complex13.INF.multiply((-2481));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex1));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex14);
assertTrue(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex4);
assertSame(complex14, complex11);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex13);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
Complex complex15 = complex7.exp();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertTrue(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertNotNull(complex15);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex15.getReal(), 0.01);
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex13);
Complex complex16 = complex15.sin();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertTrue(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex15.getReal(), 0.01);
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertEquals(0.41078129050290885, complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex14);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex12);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex13);
complex11.hashCode();
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex12));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertTrue(complex11.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex12);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex1);
assertSame(complex11, complex14);
Complex complex17 = complex13.divide((-1066.75682402));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals((-0.0025481738361095136), complex17.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex13);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
boolean boolean0 = complex13.equals(complex10);
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex16));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex13);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex16);
assertNotSame(complex8, complex17);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex14);
assertNotSame(complex8, complex15);
assertNotSame(complex8, complex10);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex13);
assertNotSame(complex8, complex12);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex4);
assertSame(complex9, complex10);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex2);
assertSame(complex9, complex12);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex17);
assertNotSame(complex10, complex15);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex16);
assertSame(complex10, complex9);
assertNotSame(complex10, complex14);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertSame(complex10, complex12);
assertNotSame(complex10, complex17);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex13);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex5);
Complex complex18 = complex14.tanh();
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex1));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex14));
assertTrue(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex18);
assertTrue(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex4);
assertSame(complex14, complex11);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex2);
assertSame(complex18, complex12);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex15);
assertSame(complex18, complex10);
assertSame(complex18, complex9);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex7);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex18);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex0);
Complex complex19 = complex17.multiply((-1066.75682402));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex2));
assertTrue(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex14));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals((-0.0025481738361095136), complex17.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertFalse(complex19.isInfinite());
assertFalse(complex19.isNaN());
assertEquals(-0.0, complex19.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex19.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
Complex complex20 = complex18.tanh();
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex1));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex19));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex14));
assertTrue(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex19));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex14));
assertTrue(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex19));
assertTrue(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex20);
assertTrue(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertTrue(complex20.isNaN());
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
double double2 = complex12.getImaginary();
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex11));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex16));
assertFalse(complex8.equals((Object)complex17));
assertFalse(complex8.equals((Object)complex5));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex14));
assertFalse(complex8.equals((Object)complex15));
assertFalse(complex8.equals((Object)complex18));
assertFalse(complex8.equals((Object)complex10));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex20));
assertFalse(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex13));
assertFalse(complex8.equals((Object)complex19));
assertFalse(complex8.equals((Object)complex12));
assertNotEquals(double2, double0, 0.01);
assertNotEquals(double2, double1, 0.01);
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex19));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex16));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex19));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex18));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex17));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex12));
assertTrue(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex19));
assertFalse(complex11.equals((Object)complex20));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex19));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex11));
assertTrue(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex0));
assertEquals(Double.NaN, double2, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertTrue(complex11.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex11.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
Complex complex21 = complex14.multiply(complex19);
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex1));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex19));
assertFalse(complex14.equals((Object)complex18));
assertFalse(complex14.equals((Object)complex20));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex18));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex20));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex19));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex2));
assertTrue(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex14));
assertTrue(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex20));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex20));
assertFalse(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex10));
assertFalse(complex21.equals((Object)complex1));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex12));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex17));
assertTrue(complex21.equals((Object)complex6));
assertFalse(complex21.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex2));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex3));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex19));
assertTrue(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex21);
assertTrue(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex14.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex14.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals((-0.0025481738361095136), complex17.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertFalse(complex19.isInfinite());
assertFalse(complex19.isNaN());
assertEquals(-0.0, complex19.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex19.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(-0.0, complex7.getImaginary(), 0.01);
assertTrue(complex21.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex21.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex21.getImaginary(), 0.01);
assertFalse(complex21.isNaN());
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(2.718281828459045, complex13.getReal(), 0.01);
Complex complex22 = Complex.valueOf(0.0);
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex18));
assertTrue(complex22.equals((Object)complex3));
assertTrue(complex22.equals((Object)complex0));
assertFalse(complex22.equals((Object)complex11));
assertFalse(complex22.equals((Object)complex7));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex2));
assertFalse(complex22.equals((Object)complex9));
assertFalse(complex22.equals((Object)complex21));
assertFalse(complex22.equals((Object)complex12));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex10));
assertTrue(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex1));
assertFalse(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex14));
assertNotNull(complex22);
assertEquals(0.0, complex22.getImaginary(), 0.01);
assertFalse(complex22.isNaN());
assertEquals(0.0, complex22.getReal(), 0.01);
assertFalse(complex22.isInfinite());
}
@Test(timeout = 4000)
public void test085() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = Complex.valueOf(1584.26118303839, 2940.462594);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertNotSame(complex1, complex0);
Complex complex2 = complex0.pow(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.NaN.sqrt1z();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.NaN.negate();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertSame(complex4, complex3);
Complex complex5 = (Complex)complex1.ONE.readResolve();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
Complex complex6 = complex0.multiply(1684);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
Complex complex7 = complex6.multiply(complex0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertNotNull(complex7);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
Complex complex8 = complex1.tan();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(1.0, complex8.getImaginary(), 0.01);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
Complex complex9 = Complex.valueOf(2940.462594);
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertFalse(complex9.isInfinite());
assertEquals(2940.462594, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
Complex complex10 = complex2.multiply((-226));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex8));
assertTrue(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex7);
assertSame(complex10, complex3);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex0);
assertSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex5);
Complex complex11 = complex2.divide(complex7);
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex8));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex9));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex10));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex1));
assertTrue(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex0));
assertNotNull(complex11);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(2940.462594, complex1.getImaginary(), 0.01);
assertEquals(1584.26118303839, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex7);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex3);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertSame(complex11, complex10);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex2);
assertSame(complex11, complex3);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex0);
assertSame(complex11, complex4);
}
@Test(timeout = 4000)
public void test086() throws Throwable {
Complex complex0 = Complex.valueOf(0.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.asin();
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.subtract(0.0);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex2.multiply(994.191);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
Complex complex4 = complex3.ONE.multiply(2021.0);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2021.0, complex4.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
double double0 = complex3.abs();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
Complex complex5 = complex3.I.add(complex0);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
Complex complex6 = complex2.add(complex1);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
Complex complex7 = complex6.NaN.add(complex1);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex5));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex5);
Complex complex8 = complex6.INF.sin();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertTrue(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
double double1 = complex0.INF.abs();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertNotEquals(double1, double0, 0.01);
assertEquals(Double.POSITIVE_INFINITY, double1, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
Complex complex9 = complex2.sqrt();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex0));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex5));
assertTrue(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex4));
assertTrue(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex9.isInfinite());
assertEquals(0.0, complex9.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex1);
Complex complex10 = complex6.ONE.multiply(1);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex1);
Complex complex11 = complex10.I.add(complex4);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex10));
assertTrue(complex3.equals((Object)complex9));
assertTrue(complex3.equals((Object)complex6));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertNotNull(complex11);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(2021.0, complex4.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(2021.0, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(1.0, complex11.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex7);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex1);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
List<Complex> list0 = complex10.I.nthRoot(1);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex11));
assertTrue(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(list0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertEquals(1, list0.size());
assertFalse(list0.isEmpty());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex4);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex1);
List<Complex> list1 = complex0.nthRoot(185);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(list1.equals((Object)list0));
assertNotNull(list1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(list1.isEmpty());
assertEquals(185, list1.size());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(list1, list0);
Complex complex12 = complex0.sqrt();
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex0));
assertTrue(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertTrue(complex12.equals((Object)complex2));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex10));
assertTrue(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertNotNull(complex12);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
Complex complex13 = complex12.ONE.multiply(complex2);
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex0));
assertTrue(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertTrue(complex12.equals((Object)complex2));
assertTrue(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex10));
assertTrue(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex13.equals((Object)complex3));
assertTrue(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex7));
assertTrue(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex12));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertNotNull(complex13);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex13);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex0);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex13);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
Complex complex14 = complex13.ZERO.multiply(185);
assertFalse(complex12.equals((Object)complex5));
assertTrue(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex0));
assertTrue(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex11));
assertTrue(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex7));
assertTrue(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex8));
assertTrue(complex12.equals((Object)complex9));
assertTrue(complex12.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex13.equals((Object)complex3));
assertTrue(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertTrue(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex7));
assertTrue(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex4));
assertTrue(complex14.equals((Object)complex13));
assertTrue(complex14.equals((Object)complex3));
assertTrue(complex14.equals((Object)complex12));
assertTrue(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex7));
assertTrue(complex14.equals((Object)complex9));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex5));
assertTrue(complex14.equals((Object)complex0));
assertTrue(complex14.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex12));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex13));
assertTrue(complex2.equals((Object)complex1));
assertNotNull(complex14);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertEquals(0.0, complex12.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex13.getReal(), 0.01);
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex14.getReal(), 0.01);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex14);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex14);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex9);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
Complex complex15 = complex1.NaN.multiply(6.456806922371733E-8);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex13));
assertTrue(complex1.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex5));
assertTrue(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex10));
assertNotNull(complex15);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex15.getImaginary(), 0.01);
assertFalse(complex15.isInfinite());
assertTrue(complex15.isNaN());
assertEquals(Double.NaN, complex15.getReal(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex8);
assertSame(complex15, complex7);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex10);
Complex complex16 = complex0.divide(2416.66744);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertTrue(complex16.equals((Object)complex14));
assertTrue(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex15));
assertTrue(complex16.equals((Object)complex2));
assertTrue(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex6));
assertTrue(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex5));
assertTrue(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertTrue(complex16.equals((Object)complex1));
assertTrue(complex16.equals((Object)complex9));
assertNotNull(complex16);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getReal(), 0.01);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex1);
ComplexField complexField0 = complex16.I.getField();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex7));
assertTrue(complex16.equals((Object)complex14));
assertTrue(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex15));
assertTrue(complex16.equals((Object)complex2));
assertTrue(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex10));
assertTrue(complex16.equals((Object)complex6));
assertTrue(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex5));
assertTrue(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex8));
assertTrue(complex16.equals((Object)complex1));
assertTrue(complex16.equals((Object)complex9));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertEquals(0.0, complex16.getReal(), 0.01);
assertEquals(0.0, complex16.getImaginary(), 0.01);
assertFalse(complex16.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex1);
Complex complex17 = complex2.INF.createComplex(1.0, 0.0);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex13));
assertTrue(complex1.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex15));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex16));
assertTrue(complex2.equals((Object)complex13));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex15));
assertTrue(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex2));
assertNotNull(complex17);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertEquals(1.0, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex17.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex16);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex2);
Complex complex18 = complex3.createComplex(0.0, 4140.1658949459);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex15));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex17));
assertTrue(complex2.equals((Object)complex13));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex14));
assertTrue(complex3.equals((Object)complex12));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertTrue(complex3.equals((Object)complex9));
assertTrue(complex3.equals((Object)complex6));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex11));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex8));
assertTrue(complex3.equals((Object)complex13));
assertTrue(complex3.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex14));
assertNotNull(complex18);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex18.isInfinite());
assertEquals(4140.1658949459, complex18.getImaginary(), 0.01);
assertEquals(0.0, complex18.getReal(), 0.01);
assertFalse(complex18.isNaN());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex16);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex14);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex14);
Complex complex19 = complex5.tan();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex18));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex15));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex17));
assertTrue(complex2.equals((Object)complex13));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex14));
assertTrue(complex3.equals((Object)complex12));
assertTrue(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex4));
assertTrue(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex10));
assertTrue(complex3.equals((Object)complex9));
assertTrue(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex18));
assertTrue(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex11));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex8));
assertTrue(complex3.equals((Object)complex13));
assertTrue(complex3.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex11));
assertNotNull(complex19);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.0, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex19.isNaN());
assertEquals(0.7615941559557649, complex19.getImaginary(), 0.01);
assertEquals(0.0, complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex19);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex19);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex13);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex11);
Complex complex20 = complex6.reciprocal();
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex12));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex17));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex5));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex11));
assertTrue(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex10));
assertTrue(complex1.equals((Object)complex12));
assertTrue(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex2.equals((Object)complex18));
assertTrue(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex15));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertTrue(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex10));
assertTrue(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex17));
assertTrue(complex2.equals((Object)complex13));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex19));
assertTrue(complex2.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex19));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex11));
assertTrue(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex18));
assertTrue(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex14));
assertTrue(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex20.equals((Object)complex12));
assertTrue(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex19));
assertNotNull(complex20);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertEquals(Double.NaN, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertTrue(complex20.isNaN());
assertEquals(Double.NaN, complex20.getReal(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex20);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex20);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex14);
}
@Test(timeout = 4000)
public void test087() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, (-1968.22367250525));
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1968.22367250525), complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
Complex complex1 = (Complex)complex0.INF.readResolve();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1968.22367250525), complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertTrue(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
ComplexField complexField0 = complex0.ZERO.getField();
assertFalse(complex0.equals((Object)complex1));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1968.22367250525), complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex1);
Complex complex2 = complex0.ZERO.reciprocal();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1968.22367250525), complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = (Complex)complex0.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1968.22367250525), complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals((-1968.22367250525), complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = Complex.valueOf(0.0);
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
Complex complex5 = complex2.multiply(complex4);
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-1968.22367250525), complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertEquals(0.0, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertFalse(complex4.isInfinite());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertTrue(complex5.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex1);
assertSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
}
@Test(timeout = 4000)
public void test088() throws Throwable {
Complex complex0 = new Complex((-141.37), (-141.37));
assertNotNull(complex0);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
Complex complex1 = complex0.NaN.divide(233.517);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = Complex.ONE;
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = (Complex)complex1.NaN.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = complex0.pow(complex2);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-141.37000000000003), complex4.getReal(), 0.01);
assertEquals((-141.37000000000003), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
Complex complex5 = complex0.ONE.add(2.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(3.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
Complex complex6 = complex4.INF.negate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-141.37000000000003), complex4.getReal(), 0.01);
assertEquals((-141.37000000000003), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex4);
Complex complex7 = complex4.ONE.sinh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-141.37000000000003), complex4.getReal(), 0.01);
assertEquals((-141.37000000000003), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(1.1752011936438014, complex7.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
String string0 = complex0.toString();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertEquals("(-141.37, -141.37)", string0);
assertNotNull(string0);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
double double0 = complex1.ONE.getArgument();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertEquals(0.0, double0, 0.01);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
complex2.hashCode();
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
complex1.hashCode();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
Complex complex8 = complex2.multiply(3645.72407507193);
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertEquals(3645.72407507193, complex8.getReal(), 0.01);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex5);
Complex complex9 = complex2.subtract(2590.743639);
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex3));
assertNotNull(complex9);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-2589.743639), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
Complex complex10 = complex6.sinh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex7));
assertTrue(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex5));
assertNotNull(complex10);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-141.37000000000003), complex4.getReal(), 0.01);
assertEquals((-141.37000000000003), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex5);
Complex complex11 = complex0.sinh();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex9));
assertNotNull(complex11);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(1.2450314035520936E61, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals((-2.0784717244682895E58), complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex9);
Complex complex12 = complex7.pow(complex4);
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex12);
assertEquals((-8.255229958236833E-11), complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(9.054390344336311E-11, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-141.37000000000003), complex4.getReal(), 0.01);
assertEquals((-141.37000000000003), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertEquals(1.1752011936438014, complex7.getReal(), 0.01);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex11);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex12);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex2);
double double1 = complex1.getImaginary();
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertNotEquals(double1, double0, 0.01);
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertTrue(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex11));
assertEquals(Double.NaN, double1, 0.01);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex11);
Complex complex13 = complex10.multiply((-1861));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex8));
assertTrue(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex2));
assertTrue(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex11));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex12));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex7));
assertTrue(complex10.equals((Object)complex3));
assertNotNull(complex13);
assertEquals((-141.37), complex0.getImaginary(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals((-141.37), complex0.getReal(), 0.01);
assertTrue(complex13.isNaN());
assertEquals(Double.NaN, complex13.getImaginary(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(Double.NaN, complex13.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex4.isNaN());
assertEquals((-141.37000000000003), complex4.getReal(), 0.01);
assertEquals((-141.37000000000003), complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getImaginary(), 0.01);
assertTrue(complex6.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex6.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex9);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex2);
assertSame(complex13, complex1);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex4);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex11);
assertNotSame(complex10, complex13);
assertNotSame(complex10, complex12);
Complex complex14 = complex2.multiply(576.8377041867011);
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex2));
assertNotNull(complex14);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(576.8377041867011, complex14.getReal(), 0.01);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertFalse(complex14.isInfinite());
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex2);
Complex complex15 = complex9.negate();
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex12));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex0));
assertNotNull(complex15);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2589.743639, complex15.getReal(), 0.01);
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex15.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-2589.743639), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex5);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex10);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
try {
complex6.nthRoot(0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: 0
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test089() throws Throwable {
Complex complex0 = Complex.ONE;
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.acos();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.atan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertTrue(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(-0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertEquals(-0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
}
@Test(timeout = 4000)
public void test090() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
Complex complex1 = complex0.sin();
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.INF.multiply((-675.9161040961816));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex2.getReal(), 0.01);
assertTrue(complex2.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.ZERO.cos();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertEquals(1.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex2);
Complex complex4 = complex1.INF.pow((-1771.0));
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
Complex complex5 = complex1.ONE.log();
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertTrue(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
Complex complex6 = complex1.ZERO.createComplex(0.0, 2028.198732);
assertTrue(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex6.isNaN());
assertEquals(2028.198732, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
Complex complex7 = complex6.NaN.asin();
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex5));
assertTrue(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertFalse(complex6.isNaN());
assertEquals(2028.198732, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertTrue(complex7.isNaN());
assertEquals(Double.NaN, complex7.getReal(), 0.01);
assertEquals(Double.NaN, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex2);
Complex complex8 = complex0.asin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertTrue(complex8.equals((Object)complex1));
assertTrue(complex8.equals((Object)complex5));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex8.getReal(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
Complex complex9 = complex0.cosh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex8));
assertTrue(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex6));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex6);
}
@Test(timeout = 4000)
public void test091() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = Complex.INF;
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.divide(complex1);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertSame(complex0, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertSame(complex2, complex0);
}
@Test(timeout = 4000)
public void test092() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, 0.0);
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.INF.reciprocal();
assertTrue(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = Complex.valueOf(0.0);
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.multiply(complex2);
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex2));
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex0));
assertTrue(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
ComplexField complexField0 = complex1.ONE.getField();
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex2));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
Complex complex4 = (Complex)complex2.ZERO.readResolve();
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex1));
assertTrue(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
double double0 = complex0.abs();
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertEquals(0.0, double0, 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
List<Complex> list0 = complex0.nthRoot(157);
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertNotNull(list0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(157, list0.size());
assertFalse(list0.isEmpty());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertTrue(list0.contains(complex0));
double double1 = complex2.getImaginary();
assertTrue(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex0));
assertTrue(complex2.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex3));
assertEquals(double1, double0, 0.01);
assertEquals(0.0, double1, 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
boolean boolean0 = complex1.isInfinite();
assertTrue(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex2));
assertTrue(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex3));
assertTrue(complex1.equals((Object)complex2));
assertFalse(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
}
@Test(timeout = 4000)
public void test093() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.INF.asin();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
complex0.hashCode();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertNotSame(complex0, complex1);
try {
complex0.INF.multiply((Complex) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// null is not allowed
//
verifyException("org.apache.commons.math3.util.MathUtils", e);
}
}
@Test(timeout = 4000)
public void test094() throws Throwable {
double double0 = 3603.282;
Complex complex0 = new Complex(3603.282, 3603.282);
assertNotNull(complex0);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
Complex complex1 = complex0.multiply(3603.282);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.2983641171524001E7, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.2983641171524001E7, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.I.tan();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.7615941559557649, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.INF.tan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.7615941559557649, complex2.getImaginary(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isInfinite());
assertEquals(Double.NaN, complex3.getReal(), 0.01);
assertEquals(Double.NaN, complex3.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertTrue(complex3.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex0.createComplex(3603.282, 0.0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(3603.282, complex4.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
Complex complex5 = complex4.I.log();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(3603.282, complex4.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(1.5707963267948966, complex5.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
Complex complex6 = complex4.negate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(3603.282, complex4.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertFalse(complex6.isNaN());
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertEquals((-3603.282), complex6.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
double double1 = complex1.INF.getArgument();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex5));
assertNotEquals(double1, double0, 0.01);
assertEquals(0.7853981633974483, double1, 0.01);
assertEquals(3603.282, complex0.getImaginary(), 0.01);
assertEquals(3603.282, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(1.2983641171524001E7, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(1.2983641171524001E7, complex1.getReal(), 0.01);
assertFalse(complex1.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex5);
try {
complex6.nthRoot((-119));
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: -119
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test095() throws Throwable {
Complex complex0 = Complex.ZERO;
assertNotNull(complex0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
Complex complex1 = complex0.ZERO.exp();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.ONE.multiply(2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex0.NaN.createComplex((-2335.91542), 2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
ComplexField complexField0 = complex0.getField();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertNotNull(complexField0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex3);
Complex complex4 = complex0.add(2.9850404523368767E-171);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(2.9850404523368767E-171, complex4.getReal(), 0.01);
assertFalse(complex4.isNaN());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
Complex complex5 = complex2.acos();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertNotNull(complex5);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
Complex complex6 = complex2.sqrt1z();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
Complex complex7 = complex6.ONE.add(complex5);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex0));
assertNotNull(complex7);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(2.5707963267948966, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex0);
Complex complex8 = (Complex)complex5.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertNotNull(complex8);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex8);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
boolean boolean0 = complex2.equals(complex8);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex6));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex1));
assertFalse(boolean0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertFalse(complex8.isNaN());
assertFalse(complex8.isInfinite());
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertEquals(-0.0, complex8.getImaginary(), 0.01);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex7);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex8);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
Complex complex9 = complex0.cosh();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
Complex complex10 = complex9.I.reciprocal();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex4));
assertNotNull(complex10);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertFalse(complex10.isNaN());
assertEquals((-1.0), complex10.getImaginary(), 0.01);
assertEquals(0.0, complex10.getReal(), 0.01);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex4);
Complex complex11 = complex9.INF.tan();
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex11);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
Complex complex12 = complex11.INF.cos();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex0));
assertTrue(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex1));
assertNotNull(complex12);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex1);
Complex complex13 = complex3.INF.conjugate();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex12));
assertNotNull(complex13);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertTrue(complex13.isInfinite());
assertEquals(Double.NEGATIVE_INFINITY, complex13.getImaginary(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex13.getReal(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex12);
Complex complex14 = (Complex)complex11.ONE.readResolve();
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex10));
assertTrue(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex4));
assertTrue(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex0));
assertTrue(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex12));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex4));
assertTrue(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex14);
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(1.0, complex14.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex8);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
Complex complex15 = complex2.reciprocal();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex13));
assertNotNull(complex15);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(-0.0, complex15.getImaginary(), 0.01);
assertEquals(3.3500383528040207E170, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex13);
String string0 = complex0.INF.toString();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertEquals("(Infinity, Infinity)", string0);
assertNotNull(string0);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
Complex complex16 = complex0.add(complex3);
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex12));
assertTrue(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex10));
assertNotNull(complex16);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals((-2335.91542), complex16.getReal(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals(2.9850404523368767E-171, complex16.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex3.isNaN());
assertEquals((-2335.91542), complex3.getReal(), 0.01);
assertEquals(2.9850404523368767E-171, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex8);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex10);
Complex complex17 = complex11.conjugate();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex10));
assertFalse(complex17.equals((Object)complex5));
assertTrue(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertTrue(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex12));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex4));
assertTrue(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex17);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex17.isNaN());
assertEquals(Double.NaN, complex17.getImaginary(), 0.01);
assertFalse(complex17.isInfinite());
assertEquals(Double.NaN, complex17.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex3);
assertSame(complex17, complex11);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex9);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex17);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex10);
assertSame(complex11, complex17);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
Complex complex18 = complex12.asin();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex3));
assertTrue(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex16));
assertFalse(complex9.equals((Object)complex15));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex2));
assertTrue(complex9.equals((Object)complex14));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex17));
assertFalse(complex9.equals((Object)complex12));
assertTrue(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex13));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex14));
assertFalse(complex11.equals((Object)complex4));
assertTrue(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex15));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex13));
assertFalse(complex11.equals((Object)complex16));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex14));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex15));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex16));
assertFalse(complex12.equals((Object)complex13));
assertFalse(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex17));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex9));
assertTrue(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex8));
assertNotNull(complex18);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertTrue(complex18.isNaN());
assertEquals(Double.NaN, complex18.getReal(), 0.01);
assertEquals(Double.NaN, complex18.getImaginary(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals(1.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertTrue(complex11.isNaN());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex18, complex13);
assertSame(complex18, complex17);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex7);
assertSame(complex18, complex11);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex16);
assertNotSame(complex9, complex16);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex18);
assertNotSame(complex9, complex15);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex17);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex14);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex0);
assertSame(complex11, complex18);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex14);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex15);
assertNotSame(complex11, complex10);
assertSame(complex11, complex17);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex16);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex12, complex18);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex14);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex15);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex16);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex17);
assertNotSame(complex12, complex8);
boolean boolean1 = complex5.equals(complex0);
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertTrue(boolean1 == boolean0);
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex8));
assertFalse(boolean1);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(1.5707963267948966, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertEquals(-0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex16);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex8);
Complex complex19 = complex6.exp();
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex11));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex7));
assertTrue(complex1.equals((Object)complex14));
assertTrue(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex17));
assertFalse(complex1.equals((Object)complex12));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex10));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex14));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex9));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex16));
assertFalse(complex6.equals((Object)complex18));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex11));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex17));
assertNotNull(complex19);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex1.isNaN());
assertFalse(complex1.isInfinite());
assertEquals(1.0, complex1.getReal(), 0.01);
assertEquals(0.0, complex1.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertFalse(complex2.isNaN());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(2.9850404523368767E-171, complex2.getReal(), 0.01);
assertEquals(2.718281828459045, complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex19.isNaN());
assertFalse(complex6.isNaN());
assertEquals(1.0, complex6.getReal(), 0.01);
assertEquals(0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex16);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex18);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex11);
assertNotSame(complex1, complex3);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex19);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex17);
assertNotSame(complex1, complex12);
assertNotSame(complex1, complex14);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex10);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex15);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex19);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex16);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex11);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex8);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex15);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex18);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex19);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex17);
}
@Test(timeout = 4000)
public void test096() throws Throwable {
Complex complex0 = new Complex(0.0);
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
Complex complex1 = complex0.NaN.add(0.0);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
ComplexField complexField0 = complex1.I.getField();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.NaN.multiply(258);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = complex1.ONE.tan();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
Complex complex4 = (Complex)complex2.NaN.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertTrue(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertTrue(complex2.isNaN());
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex4.isNaN());
assertEquals(Double.NaN, complex4.getReal(), 0.01);
assertEquals(Double.NaN, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertSame(complex2, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex3);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
Complex complex5 = (Complex)complex0.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertTrue(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex4);
Complex complex6 = complex0.asin();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
Complex complex7 = complex0.subtract(0.0);
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex2));
assertTrue(complex7.equals((Object)complex5));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
Complex complex8 = complex6.ZERO.pow(complex3);
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex5));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertTrue(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex2));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex3);
Complex complex9 = (Complex)complex1.readResolve();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex3));
assertTrue(complex9.equals((Object)complex2));
assertTrue(complex9.equals((Object)complex8));
assertTrue(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex9.getImaginary(), 0.01);
assertFalse(complex9.isInfinite());
assertTrue(complex9.isNaN());
assertEquals(Double.NaN, complex9.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
Complex complex10 = complex6.reciprocal();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex4));
assertTrue(complex10.equals((Object)complex9));
assertTrue(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex7));
assertNotNull(complex10);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex8);
assertSame(complex10, complex1);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex7);
assertSame(complex10, complex2);
Complex complex11 = complex6.INF.atan();
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex10));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex7));
assertTrue(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertTrue(complex11.equals((Object)complex9));
assertTrue(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertNotNull(complex11);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertSame(complex11, complex10);
assertSame(complex11, complex1);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
Complex complex12 = complex11.I.divide(complex8);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex10));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex6));
assertTrue(complex8.equals((Object)complex10));
assertTrue(complex8.equals((Object)complex4));
assertTrue(complex8.equals((Object)complex9));
assertFalse(complex8.equals((Object)complex0));
assertTrue(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertTrue(complex8.equals((Object)complex11));
assertTrue(complex8.equals((Object)complex2));
assertTrue(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex5));
assertTrue(complex11.equals((Object)complex9));
assertTrue(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex3));
assertTrue(complex12.equals((Object)complex4));
assertTrue(complex12.equals((Object)complex9));
assertTrue(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex7));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertEquals(Double.NaN, complex11.getImaginary(), 0.01);
assertFalse(complex11.isInfinite());
assertEquals(Double.NaN, complex11.getReal(), 0.01);
assertTrue(complex11.isNaN());
assertEquals(Double.NaN, complex12.getImaginary(), 0.01);
assertFalse(complex12.isInfinite());
assertTrue(complex12.isNaN());
assertEquals(Double.NaN, complex12.getReal(), 0.01);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertSame(complex1, complex12);
assertSame(complex1, complex10);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex3);
assertSame(complex1, complex11);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex11);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex12);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex10);
assertSame(complex11, complex2);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertSame(complex11, complex12);
assertSame(complex11, complex10);
assertSame(complex11, complex1);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex6);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertSame(complex12, complex1);
assertSame(complex12, complex2);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex3);
assertSame(complex12, complex11);
assertSame(complex12, complex10);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex7);
Complex complex13 = complex3.ZERO.subtract(complex6);
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex2));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex10));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex10));
assertTrue(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex3));
assertTrue(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex2));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals(0.0, complex13.getReal(), 0.01);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertSame(complex1, complex11);
assertSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex12);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex2);
String string0 = complex7.ZERO.toString();
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex11));
assertTrue(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertEquals("(0.0, 0.0)", string0);
assertNotNull(string0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
ComplexField complexField1 = complex6.getField();
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex12));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertNotNull(complexField1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertSame(complexField1, complexField0);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex8);
complex3.hashCode();
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex1.equals((Object)complex9));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex13);
assertNotSame(complex1, complex8);
assertNotSame(complex1, complex5);
assertSame(complex1, complex10);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertSame(complex1, complex11);
assertSame(complex1, complex12);
assertNotSame(complex1, complex0);
assertSame(complex1, complex2);
assertNotSame(complex1, complex7);
assertNotSame(complex1, complex9);
assertNotSame(complex1, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex12);
Complex complex14 = complex0.cos();
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertNotNull(complex14);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(1.0, complex14.getReal(), 0.01);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
Complex complex15 = complex7.I.sinh();
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex11));
assertTrue(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex15);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.8414709848078965, complex15.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex1);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
Complex complex16 = complex15.acos();
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex4));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex11));
assertTrue(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex16);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.8414709848078965, complex15.getImaginary(), 0.01);
assertFalse(complex16.isInfinite());
assertFalse(complex16.isNaN());
assertEquals(1.5707963267948966, complex16.getReal(), 0.01);
assertEquals((-0.764725154011207), complex16.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex1);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex3);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex10);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
Complex complex17 = complex15.ZERO.add(0.0);
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex10));
assertTrue(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex1));
assertFalse(complex17.equals((Object)complex15));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex2));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex9));
assertTrue(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex4));
assertTrue(complex17.equals((Object)complex0));
assertTrue(complex17.equals((Object)complex7));
assertTrue(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex16));
assertTrue(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(0.0, complex15.getReal(), 0.01);
assertFalse(complex15.isInfinite());
assertFalse(complex15.isNaN());
assertEquals(0.8414709848078965, complex15.getImaginary(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertFalse(complex17.isInfinite());
assertEquals(0.0, complex17.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex9);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex1);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex15);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex15);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex8);
Complex complex18 = complex14.ONE.multiply(complex6);
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex16));
assertFalse(complex14.equals((Object)complex17));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex15));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex3));
assertTrue(complex18.equals((Object)complex0));
assertTrue(complex18.equals((Object)complex7));
assertTrue(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex4));
assertTrue(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex18.equals((Object)complex1));
assertTrue(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex10));
assertTrue(complex18.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex16));
assertTrue(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex12));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex15));
assertNotNull(complex18);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals(0.0, complex18.getReal(), 0.01);
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertNotSame(complex0, complex17);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex4);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex16);
assertNotSame(complex14, complex17);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex15);
assertNotSame(complex14, complex18);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex9);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex10);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex13);
assertNotSame(complex6, complex16);
assertNotSame(complex6, complex17);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex12);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex14);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex18);
Complex complex19 = complex7.tan();
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex2));
assertTrue(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex1));
assertTrue(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex15));
assertFalse(complex19.equals((Object)complex16));
assertTrue(complex19.equals((Object)complex5));
assertTrue(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex19.equals((Object)complex4));
assertTrue(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex9));
assertTrue(complex19.equals((Object)complex6));
assertTrue(complex19.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex16));
assertTrue(complex7.equals((Object)complex13));
assertTrue(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex6));
assertTrue(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex15));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex19.isNaN());
assertFalse(complex19.isInfinite());
assertEquals(0.0, complex19.getReal(), 0.01);
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
Complex complex20 = Complex.valueOf(0.0);
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex2));
assertTrue(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex4));
assertTrue(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex3));
assertTrue(complex20.equals((Object)complex0));
assertTrue(complex20.equals((Object)complex6));
assertTrue(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex1));
assertTrue(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex9));
assertTrue(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex16));
assertNotNull(complex20);
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getReal(), 0.01);
Complex complex21 = complex1.acos();
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex6));
assertTrue(complex21.equals((Object)complex8));
assertTrue(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex3));
assertTrue(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex17));
assertNotNull(complex21);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertTrue(complex21.isNaN());
boolean boolean0 = complex10.isNaN();
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex16));
assertTrue(complex6.equals((Object)complex20));
assertTrue(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex12));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex21));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex19));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex18));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex10.equals((Object)complex6));
assertTrue(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex18));
assertTrue(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex13));
assertFalse(complex10.equals((Object)complex16));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex14));
assertFalse(complex10.equals((Object)complex15));
assertTrue(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex17));
assertFalse(complex10.equals((Object)complex20));
assertFalse(complex10.equals((Object)complex19));
assertTrue(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertTrue(complex10.isNaN());
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertFalse(complex10.isInfinite());
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
Complex complex22 = complex21.sin();
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex6));
assertTrue(complex21.equals((Object)complex8));
assertTrue(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex3));
assertTrue(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex7));
assertTrue(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex17));
assertTrue(complex22.equals((Object)complex9));
assertTrue(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex0));
assertNotNull(complex22);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertTrue(complex21.isNaN());
assertEquals(Double.NaN, complex22.getImaginary(), 0.01);
assertFalse(complex22.isInfinite());
assertTrue(complex22.isNaN());
assertEquals(Double.NaN, complex22.getReal(), 0.01);
ComplexField complexField2 = complex22.getField();
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex21.equals((Object)complex13));
assertFalse(complex21.equals((Object)complex16));
assertFalse(complex21.equals((Object)complex7));
assertFalse(complex21.equals((Object)complex5));
assertFalse(complex21.equals((Object)complex14));
assertFalse(complex21.equals((Object)complex0));
assertFalse(complex21.equals((Object)complex15));
assertFalse(complex21.equals((Object)complex6));
assertTrue(complex21.equals((Object)complex8));
assertTrue(complex21.equals((Object)complex9));
assertFalse(complex21.equals((Object)complex18));
assertFalse(complex21.equals((Object)complex19));
assertFalse(complex21.equals((Object)complex3));
assertTrue(complex21.equals((Object)complex4));
assertFalse(complex21.equals((Object)complex20));
assertFalse(complex21.equals((Object)complex17));
assertFalse(complex22.equals((Object)complex3));
assertFalse(complex22.equals((Object)complex20));
assertFalse(complex22.equals((Object)complex16));
assertFalse(complex22.equals((Object)complex6));
assertFalse(complex22.equals((Object)complex13));
assertFalse(complex22.equals((Object)complex18));
assertFalse(complex22.equals((Object)complex15));
assertFalse(complex22.equals((Object)complex14));
assertFalse(complex22.equals((Object)complex5));
assertFalse(complex22.equals((Object)complex7));
assertTrue(complex22.equals((Object)complex8));
assertFalse(complex22.equals((Object)complex19));
assertFalse(complex22.equals((Object)complex17));
assertTrue(complex22.equals((Object)complex9));
assertTrue(complex22.equals((Object)complex4));
assertFalse(complex22.equals((Object)complex0));
assertNotNull(complexField2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex21.getReal(), 0.01);
assertEquals(Double.NaN, complex21.getImaginary(), 0.01);
assertFalse(complex21.isInfinite());
assertTrue(complex21.isNaN());
assertEquals(Double.NaN, complex22.getImaginary(), 0.01);
assertFalse(complex22.isInfinite());
assertTrue(complex22.isNaN());
assertEquals(Double.NaN, complex22.getReal(), 0.01);
Complex complex23 = complex1.cos();
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex21));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex0));
assertFalse(complex23.equals((Object)complex15));
assertFalse(complex23.equals((Object)complex14));
assertTrue(complex23.equals((Object)complex9));
assertFalse(complex23.equals((Object)complex13));
assertFalse(complex23.equals((Object)complex16));
assertTrue(complex23.equals((Object)complex8));
assertFalse(complex23.equals((Object)complex5));
assertFalse(complex23.equals((Object)complex7));
assertFalse(complex23.equals((Object)complex20));
assertFalse(complex23.equals((Object)complex6));
assertFalse(complex23.equals((Object)complex3));
assertTrue(complex23.equals((Object)complex4));
assertFalse(complex23.equals((Object)complex18));
assertFalse(complex23.equals((Object)complex17));
assertFalse(complex23.equals((Object)complex19));
assertNotNull(complex23);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(Double.NaN, complex23.getImaginary(), 0.01);
assertFalse(complex23.isInfinite());
assertTrue(complex23.isNaN());
assertEquals(Double.NaN, complex23.getReal(), 0.01);
Complex complex24 = complex20.reciprocal();
assertTrue(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex2));
assertTrue(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex21));
assertFalse(complex20.equals((Object)complex4));
assertTrue(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex3));
assertTrue(complex20.equals((Object)complex0));
assertTrue(complex20.equals((Object)complex6));
assertFalse(complex20.equals((Object)complex22));
assertFalse(complex20.equals((Object)complex23));
assertTrue(complex20.equals((Object)complex13));
assertFalse(complex20.equals((Object)complex14));
assertFalse(complex20.equals((Object)complex1));
assertTrue(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex9));
assertTrue(complex20.equals((Object)complex18));
assertFalse(complex20.equals((Object)complex15));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex16));
assertTrue(complex24.equals((Object)complex4));
assertFalse(complex24.equals((Object)complex17));
assertFalse(complex24.equals((Object)complex6));
assertFalse(complex24.equals((Object)complex13));
assertFalse(complex24.equals((Object)complex16));
assertFalse(complex24.equals((Object)complex14));
assertFalse(complex24.equals((Object)complex5));
assertFalse(complex24.equals((Object)complex7));
assertTrue(complex24.equals((Object)complex8));
assertFalse(complex24.equals((Object)complex18));
assertTrue(complex24.equals((Object)complex9));
assertFalse(complex24.equals((Object)complex0));
assertFalse(complex24.equals((Object)complex15));
assertFalse(complex24.equals((Object)complex3));
assertFalse(complex24.equals((Object)complex19));
assertFalse(complex24.equals((Object)complex20));
assertNotNull(complex24);
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex20.isInfinite());
assertFalse(complex20.isNaN());
assertEquals(0.0, complex20.getReal(), 0.01);
assertEquals(Double.NaN, complex24.getReal(), 0.01);
assertEquals(Double.NaN, complex24.getImaginary(), 0.01);
assertFalse(complex24.isInfinite());
assertTrue(complex24.isNaN());
complex7.hashCode();
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex3));
assertTrue(complex7.equals((Object)complex0));
assertTrue(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex21));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex22));
assertFalse(complex7.equals((Object)complex16));
assertTrue(complex7.equals((Object)complex20));
assertTrue(complex7.equals((Object)complex13));
assertTrue(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex12));
assertTrue(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex23));
assertFalse(complex7.equals((Object)complex15));
assertTrue(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex24));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex7.isNaN());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertEquals(0.0, complex7.getReal(), 0.01);
Complex complex25 = complex13.multiply(0.0);
assertFalse(complex25.equals((Object)complex16));
assertFalse(complex25.equals((Object)complex23));
assertTrue(complex25.equals((Object)complex18));
assertFalse(complex25.equals((Object)complex8));
assertFalse(complex25.equals((Object)complex24));
assertFalse(complex25.equals((Object)complex2));
assertFalse(complex25.equals((Object)complex9));
assertFalse(complex25.equals((Object)complex12));
assertFalse(complex25.equals((Object)complex4));
assertFalse(complex25.equals((Object)complex14));
assertTrue(complex25.equals((Object)complex5));
assertFalse(complex25.equals((Object)complex21));
assertFalse(complex25.equals((Object)complex11));
assertFalse(complex25.equals((Object)complex22));
assertTrue(complex25.equals((Object)complex20));
assertFalse(complex25.equals((Object)complex1));
assertTrue(complex25.equals((Object)complex17));
assertTrue(complex25.equals((Object)complex13));
assertTrue(complex25.equals((Object)complex6));
assertFalse(complex25.equals((Object)complex15));
assertTrue(complex25.equals((Object)complex0));
assertTrue(complex25.equals((Object)complex19));
assertFalse(complex25.equals((Object)complex10));
assertFalse(complex25.equals((Object)complex3));
assertTrue(complex25.equals((Object)complex7));
assertTrue(complex0.equals((Object)complex20));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex11));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex21));
assertFalse(complex3.equals((Object)complex22));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex24));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex23));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex6.equals((Object)complex1));
assertTrue(complex6.equals((Object)complex17));
assertFalse(complex6.equals((Object)complex16));
assertTrue(complex6.equals((Object)complex20));
assertFalse(complex6.equals((Object)complex23));
assertTrue(complex6.equals((Object)complex13));
assertFalse(complex6.equals((Object)complex12));
assertTrue(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex21));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex14));
assertFalse(complex6.equals((Object)complex4));
assertTrue(complex6.equals((Object)complex7));
assertTrue(complex6.equals((Object)complex19));
assertFalse(complex6.equals((Object)complex3));
assertTrue(complex6.equals((Object)complex18));
assertFalse(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex22));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex8));
assertFalse(complex6.equals((Object)complex15));
assertFalse(complex6.equals((Object)complex24));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex22));
assertFalse(complex13.equals((Object)complex4));
assertTrue(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex10));
assertTrue(complex13.equals((Object)complex6));
assertTrue(complex13.equals((Object)complex20));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex3));
assertTrue(complex13.equals((Object)complex0));
assertTrue(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex21));
assertFalse(complex13.equals((Object)complex24));
assertTrue(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex23));
assertTrue(complex13.equals((Object)complex17));
assertTrue(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex16));
assertNotNull(complex25);
assertEquals(0.0, complex25.getReal(), 0.01);
assertFalse(complex25.isInfinite());
assertEquals(0.0, complex25.getImaginary(), 0.01);
assertFalse(complex25.isNaN());
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(0.0, complex6.getReal(), 0.01);
assertEquals(-0.0, complex6.getImaginary(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertFalse(complex13.isNaN());
assertFalse(complex13.isInfinite());
assertEquals(0.0, complex13.getReal(), 0.01);
boolean boolean1 = complex3.isNaN();
assertTrue(complex0.equals((Object)complex20));
assertTrue(complex0.equals((Object)complex6));
assertTrue(complex0.equals((Object)complex25));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex22));
assertFalse(complex0.equals((Object)complex24));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex8));
assertTrue(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex23));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex10));
assertTrue(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex9));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex21));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex4));
assertFalse(boolean1 == boolean0);
assertFalse(complex1.equals((Object)complex16));
assertTrue(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex13));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex19));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex1.equals((Object)complex20));
assertFalse(complex1.equals((Object)complex17));
assertTrue(complex1.equals((Object)complex9));
assertFalse(complex1.equals((Object)complex18));
assertFalse(complex1.equals((Object)complex25));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex14));
assertFalse(complex1.equals((Object)complex15));
assertFalse(complex1.equals((Object)complex7));
assertFalse(complex1.equals((Object)complex6));
assertTrue(complex1.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex21));
assertFalse(complex3.equals((Object)complex22));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex24));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex20));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex18));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex25));
assertFalse(complex3.equals((Object)complex19));
assertFalse(complex3.equals((Object)complex23));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex10));
assertFalse(boolean1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertTrue(complex1.isNaN());
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(1.557407724654902, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
}
@Test(timeout = 4000)
public void test097() throws Throwable {
Complex complex0 = Complex.valueOf(0.0, (-120.669122130752));
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
Complex complex1 = complex0.INF.tanh();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = (Complex)complex1.I.readResolve();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertEquals(Double.NaN, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex1.getImaginary(), 0.01);
assertFalse(complex1.isInfinite());
assertTrue(complex1.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertEquals(1.0, complex2.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex2);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex0);
Complex complex3 = Complex.valueOf(0.0);
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertEquals(0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex1);
Complex complex4 = complex0.cos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
complex4.INF.hashCode();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
Complex complex5 = complex4.I.pow(1829.197452202);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-0.30520833343431525), complex5.getReal(), 0.01);
assertEquals(0.9522856048488015, complex5.getImaginary(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
Complex complex6 = complex5.INF.sin();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-0.30520833343431525), complex5.getReal(), 0.01);
assertEquals(0.9522856048488015, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
Complex complex7 = complex4.tan();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(3.7558595038732414, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
double double0 = complex7.abs();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex2));
assertEquals(3.7558595038732414, double0, 0.01);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertEquals(3.7558595038732414, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex2);
Complex complex8 = complex0.acos();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertEquals(5.486216621324153, complex8.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
complex8.ZERO.hashCode();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertEquals(5.486216621324153, complex8.getImaginary(), 0.01);
assertEquals(1.5707963267948966, complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertFalse(complex8.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex6);
Complex complex9 = Complex.valueOf((-120.669122130752));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertNotNull(complex9);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals((-120.669122130752), complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
Complex complex10 = complex9.INF.tan();
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex4));
assertTrue(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex9));
assertNotNull(complex10);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertEquals((-120.669122130752), complex9.getReal(), 0.01);
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals(Double.NaN, complex10.getReal(), 0.01);
assertEquals(Double.NaN, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertTrue(complex10.isNaN());
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex2);
assertSame(complex10, complex1);
assertNotSame(complex10, complex9);
Complex complex11 = Complex.valueOf(0.0);
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex8));
assertTrue(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex7));
assertNotNull(complex11);
assertFalse(complex11.isInfinite());
assertEquals(0.0, complex11.getReal(), 0.01);
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertFalse(complex11.isNaN());
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex7);
String string0 = complex6.toString();
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertTrue(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex9));
assertTrue(complex6.equals((Object)complex10));
assertFalse(complex6.equals((Object)complex11));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex7));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex8));
assertEquals("(NaN, NaN)", string0);
assertNotNull(string0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-0.30520833343431525), complex5.getReal(), 0.01);
assertEquals(0.9522856048488015, complex5.getImaginary(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex8);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex9);
assertNotSame(complex6, complex11);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex10);
assertNotSame(complex6, complex8);
assertNotSame(complex6, complex1);
boolean boolean0 = complex5.equals(complex7);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex6));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex7.equals((Object)complex2));
assertFalse(boolean0);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.2732212601677111E52, complex4.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertEquals((-0.30520833343431525), complex5.getReal(), 0.01);
assertEquals(0.9522856048488015, complex5.getImaginary(), 0.01);
assertEquals(3.7558595038732414, complex7.getReal(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex8);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex6);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex2);
Complex complex12 = complex0.divide(3.7558595038732414);
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex1));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertFalse(complex0.isNaN());
assertEquals(0.0, complex0.getReal(), 0.01);
assertEquals((-120.669122130752), complex0.getImaginary(), 0.01);
assertEquals((-32.12823110297699), complex12.getImaginary(), 0.01);
assertEquals(0.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex1);
try {
complex10.nthRoot(0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: 0
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test098() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
Complex complex1 = complex0.negate();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.0), complex1.getImaginary(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.pow(complex0);
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.0), complex1.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(4.810477380965351, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.ZERO.createComplex(985.1, 985.1);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.0), complex1.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(4.810477380965351, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(985.1, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(985.1, complex3.getImaginary(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = complex3.sqrt1z();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.0), complex1.getImaginary(), 0.01);
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(4.810477380965351, complex2.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertFalse(complex3.isNaN());
assertEquals(985.1, complex3.getReal(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(985.1, complex3.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals((-985.0997462186907), complex4.getImaginary(), 0.01);
assertEquals(985.1002537813747, complex4.getReal(), 0.01);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex3);
assertNotSame(complex2, complex3);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex4);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex4);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex0);
Complex complex5 = complex1.subtract(complex0);
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertNotNull(complex5);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.0), complex1.getImaginary(), 0.01);
assertEquals((-2.0), complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
double double0 = (-1.6149279479975042E-9);
Complex complex6 = complex5.INF.cos();
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex2));
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex1.equals((Object)complex4));
assertFalse(complex1.equals((Object)complex5));
assertFalse(complex1.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex0));
assertNotNull(complex6);
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isInfinite());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(-0.0, complex1.getReal(), 0.01);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals((-1.0), complex1.getImaginary(), 0.01);
assertEquals((-2.0), complex5.getImaginary(), 0.01);
assertFalse(complex5.isNaN());
assertEquals(-0.0, complex5.getReal(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex6.isInfinite());
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex1, complex4);
assertNotSame(complex1, complex6);
assertNotSame(complex1, complex5);
assertNotSame(complex1, complex3);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex6);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex0);
try {
complex6.ONE.nthRoot(0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: 0
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test099() throws Throwable {
Complex complex0 = Complex.I;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
Complex complex1 = Complex.valueOf(0.0, 1620.5284672783175);
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1620.5284672783175, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertNotSame(complex1, complex0);
Complex complex2 = complex1.NaN.sin();
assertFalse(complex1.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex1.isInfinite());
assertFalse(complex1.isNaN());
assertEquals(1620.5284672783175, complex1.getImaginary(), 0.01);
assertEquals(0.0, complex1.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getReal(), 0.01);
assertEquals(Double.NaN, complex2.getImaginary(), 0.01);
assertFalse(complex2.isInfinite());
assertTrue(complex2.isNaN());
assertNotSame(complex1, complex2);
assertNotSame(complex1, complex0);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex0.tanh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(1.557407724654902, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
Complex complex4 = Complex.valueOf(2665.31, 914.194);
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertNotNull(complex4);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
Complex complex5 = complex3.NaN.reciprocal();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex3));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(1.557407724654902, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex3);
assertSame(complex5, complex2);
Complex complex6 = Complex.valueOf((-2203.24271), 1358.91394749);
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertNotNull(complex6);
assertFalse(complex6.isNaN());
assertEquals(1358.91394749, complex6.getImaginary(), 0.01);
assertEquals((-2203.24271), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex4);
Complex complex7 = complex4.ONE.subtract(complex6);
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex3));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex0));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex1));
assertNotNull(complex7);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertFalse(complex6.isNaN());
assertEquals(1358.91394749, complex6.getImaginary(), 0.01);
assertEquals((-2203.24271), complex6.getReal(), 0.01);
assertFalse(complex6.isInfinite());
assertEquals((-1358.91394749), complex7.getImaginary(), 0.01);
assertEquals(2204.24271, complex7.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertFalse(complex7.isInfinite());
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex3);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex7);
assertNotSame(complex6, complex4);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex0);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex1);
double double0 = complex5.I.getArgument();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex6));
assertEquals(1.5707963267948966, double0, 0.01);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(1.557407724654902, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertTrue(complex5.isNaN());
assertEquals(Double.NaN, complex5.getReal(), 0.01);
assertEquals(Double.NaN, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex3);
assertSame(complex5, complex2);
assertNotSame(complex5, complex6);
Complex complex8 = complex3.INF.divide(0.0);
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex3));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex6));
assertNotNull(complex8);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(1.557407724654902, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(Double.NaN, complex8.getReal(), 0.01);
assertTrue(complex8.isNaN());
assertEquals(Double.NaN, complex8.getImaginary(), 0.01);
assertFalse(complex8.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex7);
assertSame(complex8, complex5);
assertSame(complex8, complex2);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex6);
Complex complex9 = complex4.tan();
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertNotNull(complex9);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
Complex complex10 = complex9.ONE.pow(709.979749759658);
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex8));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex1));
assertNotNull(complex10);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(1.0, complex10.getReal(), 0.01);
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex10, complex8);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex1);
Complex complex11 = complex9.I.tan();
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertNotNull(complex11);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex11.isInfinite());
assertEquals(0.7615941559557649, complex11.getImaginary(), 0.01);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
Complex complex12 = complex11.ZERO.cos();
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertTrue(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex5));
assertNotNull(complex12);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex11.isInfinite());
assertEquals(0.7615941559557649, complex11.getImaginary(), 0.01);
assertEquals(-0.0, complex12.getImaginary(), 0.01);
assertEquals(1.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex8);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex3);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex5);
Complex complex13 = complex12.I.sqrt();
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex2));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex11));
assertFalse(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertFalse(complex9.equals((Object)complex12));
assertTrue(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex1));
assertFalse(complex9.equals((Object)complex10));
assertFalse(complex9.equals((Object)complex2));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex12));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex8));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex4));
assertTrue(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex3));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex12));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex7));
assertNotNull(complex13);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(914.194, complex4.getImaginary(), 0.01);
assertEquals(2665.31, complex4.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertEquals(1.0, complex9.getImaginary(), 0.01);
assertFalse(complex9.isNaN());
assertEquals(0.0, complex9.getReal(), 0.01);
assertEquals(0.0, complex11.getReal(), 0.01);
assertFalse(complex11.isNaN());
assertFalse(complex11.isInfinite());
assertEquals(0.7615941559557649, complex11.getImaginary(), 0.01);
assertEquals(-0.0, complex12.getImaginary(), 0.01);
assertEquals(1.0, complex12.getReal(), 0.01);
assertFalse(complex12.isInfinite());
assertFalse(complex12.isNaN());
assertFalse(complex13.isInfinite());
assertFalse(complex13.isNaN());
assertEquals(0.7071067811865475, complex13.getImaginary(), 0.01);
assertEquals(0.7071067811865476, complex13.getReal(), 0.01);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex0);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex11);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex10);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex7);
assertNotSame(complex9, complex13);
assertNotSame(complex9, complex12);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex8);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex8);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex12);
assertNotSame(complex11, complex13);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex3);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex13);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex0);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex7);
Complex complex14 = complex3.cosh();
assertFalse(complex0.equals((Object)complex7));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex8));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex13));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex3));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex2));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex11));
assertFalse(complex14.equals((Object)complex6));
assertNotNull(complex14);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getReal(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getImaginary(), 0.01);
assertFalse(complex3.isInfinite());
assertEquals(1.557407724654902, complex3.getImaginary(), 0.01);
assertEquals(0.0, complex3.getReal(), 0.01);
assertFalse(complex3.isNaN());
assertEquals(0.0, complex14.getImaginary(), 0.01);
assertFalse(complex14.isNaN());
assertEquals(0.01338820214867596, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertNotSame(complex0, complex7);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex5);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex12);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex13);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex5);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex6);
try {
complex14.I.nthRoot(0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: 0
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test100() throws Throwable {
Complex complex0 = Complex.ONE;
assertNotNull(complex0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
Complex complex1 = (Complex)complex0.INF.readResolve();
assertFalse(complex1.equals((Object)complex0));
assertNotNull(complex1);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertTrue(complex1.isInfinite());
assertEquals(Double.POSITIVE_INFINITY, complex1.getImaginary(), 0.01);
assertFalse(complex1.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex1.getReal(), 0.01);
assertNotSame(complex0, complex1);
assertNotSame(complex1, complex0);
Complex complex2 = complex0.sinh();
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertNotNull(complex2);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
Complex complex3 = complex2.ONE.multiply((-1625));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertNotNull(complex3);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-1625.0), complex3.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
Complex complex4 = complex2.multiply(complex0);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex2));
assertNotNull(complex4);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
Complex complex5 = complex4.pow(complex2);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex0));
assertNotNull(complex5);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertEquals(1.2089155649219285, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex0);
Complex complex6 = complex3.INF.cosh();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex1));
assertFalse(complex6.equals((Object)complex4));
assertFalse(complex6.equals((Object)complex0));
assertFalse(complex6.equals((Object)complex5));
assertFalse(complex6.equals((Object)complex2));
assertFalse(complex6.equals((Object)complex3));
assertNotNull(complex6);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-1625.0), complex3.getReal(), 0.01);
assertTrue(complex6.isNaN());
assertEquals(Double.NaN, complex6.getReal(), 0.01);
assertEquals(Double.NaN, complex6.getImaginary(), 0.01);
assertFalse(complex6.isInfinite());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex6, complex1);
assertNotSame(complex6, complex4);
assertNotSame(complex6, complex0);
assertNotSame(complex6, complex5);
assertNotSame(complex6, complex2);
assertNotSame(complex6, complex3);
Complex complex7 = Complex.ONE;
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertNotNull(complex7);
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
Complex complex8 = new Complex((-1625), 0.0);
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertTrue(complex8.equals((Object)complex3));
assertNotNull(complex8);
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals((-1625.0), complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
Complex complex9 = complex3.ZERO.add(complex8);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex5));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex2));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertTrue(complex3.equals((Object)complex8));
assertFalse(complex8.equals((Object)complex1));
assertFalse(complex8.equals((Object)complex0));
assertFalse(complex8.equals((Object)complex4));
assertFalse(complex8.equals((Object)complex6));
assertFalse(complex8.equals((Object)complex5));
assertFalse(complex8.equals((Object)complex7));
assertFalse(complex8.equals((Object)complex2));
assertTrue(complex8.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex4));
assertFalse(complex9.equals((Object)complex1));
assertTrue(complex9.equals((Object)complex8));
assertFalse(complex9.equals((Object)complex5));
assertFalse(complex9.equals((Object)complex6));
assertFalse(complex9.equals((Object)complex0));
assertFalse(complex9.equals((Object)complex2));
assertTrue(complex9.equals((Object)complex3));
assertFalse(complex9.equals((Object)complex7));
assertNotNull(complex9);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-1625.0), complex3.getReal(), 0.01);
assertFalse(complex8.isNaN());
assertEquals(0.0, complex8.getImaginary(), 0.01);
assertEquals((-1625.0), complex8.getReal(), 0.01);
assertFalse(complex8.isInfinite());
assertEquals(0.0, complex9.getImaginary(), 0.01);
assertEquals((-1625.0), complex9.getReal(), 0.01);
assertFalse(complex9.isInfinite());
assertFalse(complex9.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex8, complex1);
assertNotSame(complex8, complex9);
assertNotSame(complex8, complex3);
assertNotSame(complex8, complex0);
assertNotSame(complex8, complex4);
assertNotSame(complex8, complex6);
assertNotSame(complex8, complex5);
assertNotSame(complex8, complex7);
assertNotSame(complex8, complex2);
assertNotSame(complex9, complex4);
assertNotSame(complex9, complex3);
assertNotSame(complex9, complex1);
assertNotSame(complex9, complex5);
assertNotSame(complex9, complex6);
assertNotSame(complex9, complex0);
assertNotSame(complex9, complex8);
assertNotSame(complex9, complex2);
assertNotSame(complex9, complex7);
Complex complex10 = complex7.exp();
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex1));
assertFalse(complex10.equals((Object)complex4));
assertFalse(complex10.equals((Object)complex9));
assertFalse(complex10.equals((Object)complex3));
assertFalse(complex10.equals((Object)complex2));
assertFalse(complex10.equals((Object)complex6));
assertFalse(complex10.equals((Object)complex5));
assertFalse(complex10.equals((Object)complex0));
assertFalse(complex10.equals((Object)complex7));
assertFalse(complex10.equals((Object)complex8));
assertNotNull(complex10);
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertEquals(2.718281828459045, complex10.getReal(), 0.01);
assertFalse(complex10.isNaN());
assertEquals(0.0, complex10.getImaginary(), 0.01);
assertFalse(complex10.isInfinite());
assertSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex10, complex1);
assertNotSame(complex10, complex4);
assertNotSame(complex10, complex9);
assertNotSame(complex10, complex3);
assertNotSame(complex10, complex2);
assertNotSame(complex10, complex6);
assertNotSame(complex10, complex5);
assertNotSame(complex10, complex0);
assertNotSame(complex10, complex7);
assertNotSame(complex10, complex8);
Complex complex11 = complex7.ZERO.tan();
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex10));
assertFalse(complex11.equals((Object)complex7));
assertFalse(complex11.equals((Object)complex2));
assertFalse(complex11.equals((Object)complex5));
assertFalse(complex11.equals((Object)complex3));
assertFalse(complex11.equals((Object)complex0));
assertFalse(complex11.equals((Object)complex1));
assertFalse(complex11.equals((Object)complex6));
assertFalse(complex11.equals((Object)complex9));
assertFalse(complex11.equals((Object)complex4));
assertFalse(complex11.equals((Object)complex8));
assertNotNull(complex11);
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex11.isNaN());
assertEquals(0.0, complex11.getImaginary(), 0.01);
assertEquals(0.0, complex11.getReal(), 0.01);
assertFalse(complex11.isInfinite());
assertSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex11);
assertNotSame(complex11, complex10);
assertNotSame(complex11, complex7);
assertNotSame(complex11, complex2);
assertNotSame(complex11, complex5);
assertNotSame(complex11, complex3);
assertNotSame(complex11, complex0);
assertNotSame(complex11, complex1);
assertNotSame(complex11, complex6);
assertNotSame(complex11, complex9);
assertNotSame(complex11, complex4);
assertNotSame(complex11, complex8);
Complex complex12 = complex0.add(complex7);
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex8));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex7));
assertFalse(complex12.equals((Object)complex10));
assertFalse(complex12.equals((Object)complex11));
assertFalse(complex12.equals((Object)complex9));
assertFalse(complex12.equals((Object)complex2));
assertFalse(complex12.equals((Object)complex6));
assertFalse(complex12.equals((Object)complex5));
assertFalse(complex12.equals((Object)complex0));
assertFalse(complex12.equals((Object)complex4));
assertFalse(complex12.equals((Object)complex8));
assertFalse(complex12.equals((Object)complex1));
assertFalse(complex12.equals((Object)complex3));
assertNotNull(complex12);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertFalse(complex12.isInfinite());
assertEquals(2.0, complex12.getReal(), 0.01);
assertFalse(complex12.isNaN());
assertEquals(0.0, complex12.getImaginary(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex12);
assertSame(complex0, complex7);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex5);
assertSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex11);
assertNotSame(complex12, complex7);
assertNotSame(complex12, complex10);
assertNotSame(complex12, complex11);
assertNotSame(complex12, complex9);
assertNotSame(complex12, complex2);
assertNotSame(complex12, complex6);
assertNotSame(complex12, complex5);
assertNotSame(complex12, complex0);
assertNotSame(complex12, complex4);
assertNotSame(complex12, complex8);
assertNotSame(complex12, complex1);
assertNotSame(complex12, complex3);
Complex complex13 = complex0.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex13);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(1.0, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex0);
Complex complex14 = complex13.ONE.pow((double) (-1625));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex3));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex4));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex0.equals((Object)complex13));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertFalse(complex14.equals((Object)complex3));
assertTrue(complex14.equals((Object)complex7));
assertFalse(complex14.equals((Object)complex1));
assertFalse(complex14.equals((Object)complex4));
assertFalse(complex14.equals((Object)complex2));
assertTrue(complex14.equals((Object)complex13));
assertFalse(complex14.equals((Object)complex6));
assertFalse(complex14.equals((Object)complex8));
assertFalse(complex14.equals((Object)complex12));
assertFalse(complex14.equals((Object)complex11));
assertTrue(complex14.equals((Object)complex0));
assertFalse(complex14.equals((Object)complex9));
assertFalse(complex14.equals((Object)complex10));
assertFalse(complex14.equals((Object)complex5));
assertNotNull(complex14);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(1.0, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertEquals(-0.0, complex14.getImaginary(), 0.01);
assertEquals(1.0, complex14.getReal(), 0.01);
assertFalse(complex14.isInfinite());
assertFalse(complex14.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex0);
assertNotSame(complex14, complex3);
assertNotSame(complex14, complex13);
assertNotSame(complex14, complex1);
assertNotSame(complex14, complex4);
assertNotSame(complex14, complex2);
assertNotSame(complex14, complex0);
assertNotSame(complex14, complex6);
assertNotSame(complex14, complex8);
assertNotSame(complex14, complex12);
assertNotSame(complex14, complex11);
assertNotSame(complex14, complex9);
assertNotSame(complex14, complex10);
assertNotSame(complex14, complex7);
assertNotSame(complex14, complex5);
String string0 = complex4.ZERO.toString();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex2));
assertEquals("(0.0, 0.0)", string0);
assertNotNull(string0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex3);
Complex complex15 = complex3.divide((-1943.069));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex13));
assertTrue(complex3.equals((Object)complex8));
assertNotNull(complex15);
assertFalse(complex15.isInfinite());
assertEquals(0.8363058645884424, complex15.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-1625.0), complex3.getReal(), 0.01);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex13);
Complex complex16 = (Complex)complex15.INF.readResolve();
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex5));
assertFalse(complex16.equals((Object)complex11));
assertFalse(complex16.equals((Object)complex12));
assertFalse(complex16.equals((Object)complex2));
assertFalse(complex16.equals((Object)complex8));
assertFalse(complex16.equals((Object)complex7));
assertFalse(complex16.equals((Object)complex4));
assertTrue(complex16.equals((Object)complex1));
assertFalse(complex16.equals((Object)complex6));
assertFalse(complex16.equals((Object)complex13));
assertFalse(complex16.equals((Object)complex9));
assertFalse(complex16.equals((Object)complex14));
assertFalse(complex16.equals((Object)complex15));
assertFalse(complex16.equals((Object)complex10));
assertFalse(complex16.equals((Object)complex0));
assertFalse(complex16.equals((Object)complex3));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex13));
assertTrue(complex3.equals((Object)complex8));
assertNotNull(complex16);
assertFalse(complex15.isInfinite());
assertEquals(0.8363058645884424, complex15.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex16.isNaN());
assertEquals(Double.POSITIVE_INFINITY, complex16.getReal(), 0.01);
assertEquals(Double.POSITIVE_INFINITY, complex16.getImaginary(), 0.01);
assertTrue(complex16.isInfinite());
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-1625.0), complex3.getReal(), 0.01);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex16, complex5);
assertNotSame(complex16, complex11);
assertNotSame(complex16, complex12);
assertNotSame(complex16, complex2);
assertNotSame(complex16, complex8);
assertNotSame(complex16, complex7);
assertNotSame(complex16, complex4);
assertNotSame(complex16, complex6);
assertNotSame(complex16, complex13);
assertNotSame(complex16, complex1);
assertNotSame(complex16, complex9);
assertNotSame(complex16, complex14);
assertNotSame(complex16, complex15);
assertNotSame(complex16, complex10);
assertNotSame(complex16, complex0);
assertNotSame(complex16, complex3);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex13);
Complex complex17 = complex13.conjugate();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex16));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex3));
assertFalse(complex17.equals((Object)complex10));
assertTrue(complex17.equals((Object)complex0));
assertFalse(complex17.equals((Object)complex1));
assertTrue(complex17.equals((Object)complex14));
assertFalse(complex17.equals((Object)complex11));
assertTrue(complex17.equals((Object)complex7));
assertFalse(complex17.equals((Object)complex8));
assertFalse(complex17.equals((Object)complex12));
assertFalse(complex17.equals((Object)complex2));
assertTrue(complex17.equals((Object)complex13));
assertFalse(complex17.equals((Object)complex4));
assertFalse(complex17.equals((Object)complex6));
assertFalse(complex17.equals((Object)complex5));
assertFalse(complex17.equals((Object)complex9));
assertFalse(complex17.equals((Object)complex16));
assertFalse(complex17.equals((Object)complex15));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex6));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertTrue(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complex17);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertEquals(0.0, complex17.getImaginary(), 0.01);
assertFalse(complex17.isNaN());
assertEquals(1.0, complex17.getReal(), 0.01);
assertFalse(complex17.isInfinite());
assertFalse(complex13.isInfinite());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(1.0, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex5);
assertNotSame(complex17, complex3);
assertNotSame(complex17, complex10);
assertNotSame(complex17, complex14);
assertNotSame(complex17, complex1);
assertNotSame(complex17, complex7);
assertNotSame(complex17, complex11);
assertNotSame(complex17, complex13);
assertNotSame(complex17, complex8);
assertNotSame(complex17, complex12);
assertNotSame(complex17, complex2);
assertNotSame(complex17, complex4);
assertNotSame(complex17, complex6);
assertNotSame(complex17, complex5);
assertNotSame(complex17, complex0);
assertNotSame(complex17, complex9);
assertNotSame(complex17, complex16);
assertNotSame(complex17, complex15);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex0);
Complex complex18 = complex15.add((-1943.069));
assertFalse(complex15.equals((Object)complex1));
assertFalse(complex15.equals((Object)complex8));
assertFalse(complex15.equals((Object)complex13));
assertFalse(complex15.equals((Object)complex2));
assertFalse(complex15.equals((Object)complex17));
assertFalse(complex15.equals((Object)complex4));
assertFalse(complex15.equals((Object)complex6));
assertFalse(complex15.equals((Object)complex16));
assertFalse(complex15.equals((Object)complex5));
assertFalse(complex15.equals((Object)complex10));
assertFalse(complex15.equals((Object)complex11));
assertFalse(complex15.equals((Object)complex14));
assertFalse(complex15.equals((Object)complex12));
assertFalse(complex15.equals((Object)complex7));
assertFalse(complex15.equals((Object)complex3));
assertFalse(complex15.equals((Object)complex0));
assertFalse(complex15.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex4));
assertFalse(complex18.equals((Object)complex8));
assertFalse(complex18.equals((Object)complex12));
assertFalse(complex18.equals((Object)complex11));
assertFalse(complex18.equals((Object)complex13));
assertFalse(complex18.equals((Object)complex2));
assertFalse(complex18.equals((Object)complex17));
assertFalse(complex18.equals((Object)complex1));
assertFalse(complex18.equals((Object)complex6));
assertFalse(complex18.equals((Object)complex16));
assertFalse(complex18.equals((Object)complex15));
assertFalse(complex18.equals((Object)complex5));
assertFalse(complex18.equals((Object)complex10));
assertFalse(complex18.equals((Object)complex14));
assertFalse(complex18.equals((Object)complex7));
assertFalse(complex18.equals((Object)complex3));
assertFalse(complex18.equals((Object)complex0));
assertFalse(complex18.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex17));
assertFalse(complex3.equals((Object)complex10));
assertFalse(complex3.equals((Object)complex14));
assertFalse(complex3.equals((Object)complex16));
assertFalse(complex3.equals((Object)complex15));
assertFalse(complex3.equals((Object)complex12));
assertFalse(complex3.equals((Object)complex2));
assertTrue(complex3.equals((Object)complex9));
assertFalse(complex3.equals((Object)complex5));
assertFalse(complex3.equals((Object)complex4));
assertFalse(complex3.equals((Object)complex6));
assertFalse(complex3.equals((Object)complex0));
assertFalse(complex3.equals((Object)complex1));
assertFalse(complex3.equals((Object)complex7));
assertFalse(complex3.equals((Object)complex11));
assertFalse(complex3.equals((Object)complex13));
assertTrue(complex3.equals((Object)complex8));
assertNotNull(complex18);
assertFalse(complex15.isInfinite());
assertEquals(0.8363058645884424, complex15.getReal(), 0.01);
assertEquals(0.0, complex15.getImaginary(), 0.01);
assertFalse(complex15.isNaN());
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertFalse(complex18.isInfinite());
assertFalse(complex18.isNaN());
assertEquals((-1942.2326941354115), complex18.getReal(), 0.01);
assertEquals(0.0, complex18.getImaginary(), 0.01);
assertEquals(-0.0, complex3.getImaginary(), 0.01);
assertFalse(complex3.isNaN());
assertFalse(complex3.isInfinite());
assertEquals((-1625.0), complex3.getReal(), 0.01);
assertNotSame(complex15, complex1);
assertNotSame(complex15, complex8);
assertNotSame(complex15, complex13);
assertNotSame(complex15, complex2);
assertNotSame(complex15, complex17);
assertNotSame(complex15, complex4);
assertNotSame(complex15, complex6);
assertNotSame(complex15, complex16);
assertNotSame(complex15, complex5);
assertNotSame(complex15, complex10);
assertNotSame(complex15, complex11);
assertNotSame(complex15, complex14);
assertNotSame(complex15, complex12);
assertNotSame(complex15, complex7);
assertNotSame(complex15, complex3);
assertNotSame(complex15, complex18);
assertNotSame(complex15, complex0);
assertNotSame(complex15, complex9);
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex18, complex4);
assertNotSame(complex18, complex8);
assertNotSame(complex18, complex12);
assertNotSame(complex18, complex11);
assertNotSame(complex18, complex13);
assertNotSame(complex18, complex2);
assertNotSame(complex18, complex17);
assertNotSame(complex18, complex1);
assertNotSame(complex18, complex6);
assertNotSame(complex18, complex16);
assertNotSame(complex18, complex15);
assertNotSame(complex18, complex5);
assertNotSame(complex18, complex10);
assertNotSame(complex18, complex14);
assertNotSame(complex18, complex7);
assertNotSame(complex18, complex3);
assertNotSame(complex18, complex0);
assertNotSame(complex18, complex9);
assertNotSame(complex3, complex17);
assertNotSame(complex3, complex10);
assertNotSame(complex3, complex14);
assertNotSame(complex3, complex9);
assertNotSame(complex3, complex16);
assertNotSame(complex3, complex15);
assertNotSame(complex3, complex12);
assertNotSame(complex3, complex2);
assertNotSame(complex3, complex8);
assertNotSame(complex3, complex5);
assertNotSame(complex3, complex4);
assertNotSame(complex3, complex6);
assertNotSame(complex3, complex0);
assertNotSame(complex3, complex18);
assertNotSame(complex3, complex1);
assertNotSame(complex3, complex7);
assertNotSame(complex3, complex11);
assertNotSame(complex3, complex13);
Complex complex19 = (Complex)complex5.readResolve();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex10));
assertFalse(complex2.equals((Object)complex14));
assertFalse(complex2.equals((Object)complex13));
assertFalse(complex2.equals((Object)complex15));
assertFalse(complex2.equals((Object)complex17));
assertFalse(complex2.equals((Object)complex1));
assertFalse(complex2.equals((Object)complex5));
assertFalse(complex2.equals((Object)complex11));
assertTrue(complex2.equals((Object)complex4));
assertFalse(complex2.equals((Object)complex6));
assertFalse(complex2.equals((Object)complex18));
assertFalse(complex2.equals((Object)complex0));
assertFalse(complex2.equals((Object)complex12));
assertFalse(complex2.equals((Object)complex8));
assertFalse(complex2.equals((Object)complex7));
assertFalse(complex2.equals((Object)complex16));
assertFalse(complex2.equals((Object)complex9));
assertFalse(complex2.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex1));
assertFalse(complex19.equals((Object)complex4));
assertFalse(complex19.equals((Object)complex14));
assertFalse(complex19.equals((Object)complex9));
assertFalse(complex19.equals((Object)complex2));
assertFalse(complex19.equals((Object)complex6));
assertFalse(complex19.equals((Object)complex3));
assertFalse(complex19.equals((Object)complex16));
assertFalse(complex19.equals((Object)complex15));
assertTrue(complex19.equals((Object)complex5));
assertFalse(complex19.equals((Object)complex18));
assertFalse(complex19.equals((Object)complex17));
assertFalse(complex19.equals((Object)complex12));
assertFalse(complex19.equals((Object)complex10));
assertFalse(complex19.equals((Object)complex0));
assertFalse(complex19.equals((Object)complex13));
assertFalse(complex19.equals((Object)complex8));
assertFalse(complex19.equals((Object)complex7));
assertFalse(complex19.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex8));
assertFalse(complex4.equals((Object)complex12));
assertFalse(complex4.equals((Object)complex6));
assertFalse(complex4.equals((Object)complex5));
assertFalse(complex4.equals((Object)complex0));
assertFalse(complex4.equals((Object)complex7));
assertFalse(complex4.equals((Object)complex11));
assertFalse(complex4.equals((Object)complex1));
assertFalse(complex4.equals((Object)complex13));
assertFalse(complex4.equals((Object)complex16));
assertFalse(complex4.equals((Object)complex17));
assertFalse(complex4.equals((Object)complex10));
assertFalse(complex4.equals((Object)complex18));
assertFalse(complex4.equals((Object)complex14));
assertFalse(complex4.equals((Object)complex9));
assertFalse(complex4.equals((Object)complex15));
assertFalse(complex4.equals((Object)complex3));
assertTrue(complex4.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex3));
assertFalse(complex5.equals((Object)complex16));
assertFalse(complex5.equals((Object)complex17));
assertFalse(complex5.equals((Object)complex15));
assertFalse(complex5.equals((Object)complex13));
assertFalse(complex5.equals((Object)complex9));
assertFalse(complex5.equals((Object)complex7));
assertFalse(complex5.equals((Object)complex18));
assertFalse(complex5.equals((Object)complex10));
assertFalse(complex5.equals((Object)complex14));
assertFalse(complex5.equals((Object)complex0));
assertFalse(complex5.equals((Object)complex8));
assertFalse(complex5.equals((Object)complex4));
assertFalse(complex5.equals((Object)complex12));
assertFalse(complex5.equals((Object)complex1));
assertFalse(complex5.equals((Object)complex11));
assertFalse(complex5.equals((Object)complex2));
assertFalse(complex5.equals((Object)complex6));
assertNotNull(complex19);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex2.isNaN());
assertFalse(complex2.isInfinite());
assertEquals(0.0, complex2.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex2.getReal(), 0.01);
assertFalse(complex19.isNaN());
assertEquals(0.0, complex19.getImaginary(), 0.01);
assertEquals(1.2089155649219285, complex19.getReal(), 0.01);
assertFalse(complex19.isInfinite());
assertEquals(0.0, complex4.getImaginary(), 0.01);
assertFalse(complex4.isInfinite());
assertFalse(complex4.isNaN());
assertEquals(1.1752011936438014, complex4.getReal(), 0.01);
assertEquals(1.2089155649219285, complex5.getReal(), 0.01);
assertEquals(0.0, complex5.getImaginary(), 0.01);
assertFalse(complex5.isInfinite());
assertFalse(complex5.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex2, complex10);
assertNotSame(complex2, complex14);
assertNotSame(complex2, complex13);
assertNotSame(complex2, complex15);
assertNotSame(complex2, complex4);
assertNotSame(complex2, complex17);
assertNotSame(complex2, complex1);
assertNotSame(complex2, complex5);
assertNotSame(complex2, complex11);
assertNotSame(complex2, complex6);
assertNotSame(complex2, complex18);
assertNotSame(complex2, complex0);
assertNotSame(complex2, complex12);
assertNotSame(complex2, complex19);
assertNotSame(complex2, complex8);
assertNotSame(complex2, complex7);
assertNotSame(complex2, complex16);
assertNotSame(complex2, complex9);
assertNotSame(complex2, complex3);
assertNotSame(complex19, complex1);
assertNotSame(complex19, complex4);
assertNotSame(complex19, complex14);
assertNotSame(complex19, complex9);
assertNotSame(complex19, complex2);
assertNotSame(complex19, complex6);
assertNotSame(complex19, complex3);
assertNotSame(complex19, complex16);
assertNotSame(complex19, complex15);
assertNotSame(complex19, complex18);
assertNotSame(complex19, complex17);
assertNotSame(complex19, complex12);
assertNotSame(complex19, complex5);
assertNotSame(complex19, complex10);
assertNotSame(complex19, complex0);
assertNotSame(complex19, complex13);
assertNotSame(complex19, complex8);
assertNotSame(complex19, complex7);
assertNotSame(complex19, complex11);
assertNotSame(complex4, complex8);
assertNotSame(complex4, complex12);
assertNotSame(complex4, complex19);
assertNotSame(complex4, complex2);
assertNotSame(complex4, complex6);
assertNotSame(complex4, complex5);
assertNotSame(complex4, complex0);
assertNotSame(complex4, complex7);
assertNotSame(complex4, complex11);
assertNotSame(complex4, complex1);
assertNotSame(complex4, complex13);
assertNotSame(complex4, complex16);
assertNotSame(complex4, complex17);
assertNotSame(complex4, complex10);
assertNotSame(complex4, complex18);
assertNotSame(complex4, complex14);
assertNotSame(complex4, complex9);
assertNotSame(complex4, complex15);
assertNotSame(complex4, complex3);
assertNotSame(complex5, complex3);
assertNotSame(complex5, complex16);
assertNotSame(complex5, complex17);
assertNotSame(complex5, complex15);
assertNotSame(complex5, complex13);
assertNotSame(complex5, complex9);
assertNotSame(complex5, complex7);
assertNotSame(complex5, complex18);
assertNotSame(complex5, complex10);
assertNotSame(complex5, complex14);
assertNotSame(complex5, complex19);
assertNotSame(complex5, complex0);
assertNotSame(complex5, complex8);
assertNotSame(complex5, complex4);
assertNotSame(complex5, complex12);
assertNotSame(complex5, complex1);
assertNotSame(complex5, complex11);
assertNotSame(complex5, complex2);
assertNotSame(complex5, complex6);
ComplexField complexField0 = complex13.getField();
assertFalse(complex0.equals((Object)complex2));
assertFalse(complex0.equals((Object)complex11));
assertFalse(complex0.equals((Object)complex19));
assertFalse(complex0.equals((Object)complex6));
assertFalse(complex0.equals((Object)complex12));
assertFalse(complex0.equals((Object)complex1));
assertFalse(complex0.equals((Object)complex16));
assertTrue(complex0.equals((Object)complex17));
assertFalse(complex0.equals((Object)complex4));
assertTrue(complex0.equals((Object)complex13));
assertFalse(complex0.equals((Object)complex15));
assertFalse(complex0.equals((Object)complex10));
assertFalse(complex0.equals((Object)complex3));
assertTrue(complex0.equals((Object)complex14));
assertFalse(complex0.equals((Object)complex8));
assertFalse(complex0.equals((Object)complex9));
assertFalse(complex0.equals((Object)complex18));
assertFalse(complex0.equals((Object)complex5));
assertTrue(complex13.equals((Object)complex0));
assertFalse(complex13.equals((Object)complex18));
assertFalse(complex13.equals((Object)complex12));
assertTrue(complex13.equals((Object)complex7));
assertFalse(complex13.equals((Object)complex11));
assertFalse(complex13.equals((Object)complex4));
assertFalse(complex13.equals((Object)complex16));
assertFalse(complex13.equals((Object)complex2));
assertFalse(complex13.equals((Object)complex6));
assertTrue(complex13.equals((Object)complex17));
assertFalse(complex13.equals((Object)complex9));
assertFalse(complex13.equals((Object)complex10));
assertFalse(complex13.equals((Object)complex1));
assertTrue(complex13.equals((Object)complex14));
assertFalse(complex13.equals((Object)complex15));
assertFalse(complex13.equals((Object)complex8));
assertFalse(complex13.equals((Object)complex3));
assertFalse(complex13.equals((Object)complex19));
assertFalse(complex13.equals((Object)complex5));
assertNotNull(complexField0);
assertFalse(complex0.isInfinite());
assertEquals(0.0, complex0.getImaginary(), 0.01);
assertFalse(complex0.isNaN());
assertEquals(1.0, complex0.getReal(), 0.01);
assertFalse(complex13.isInfinite());
assertEquals(-0.0, complex13.getImaginary(), 0.01);
assertEquals(1.0, complex13.getReal(), 0.01);
assertFalse(complex13.isNaN());
assertNotSame(complex0, complex2);
assertNotSame(complex0, complex11);
assertNotSame(complex0, complex19);
assertNotSame(complex0, complex6);
assertNotSame(complex0, complex12);
assertNotSame(complex0, complex1);
assertNotSame(complex0, complex16);
assertNotSame(complex0, complex4);
assertNotSame(complex0, complex15);
assertNotSame(complex0, complex10);
assertNotSame(complex0, complex14);
assertNotSame(complex0, complex13);
assertNotSame(complex0, complex3);
assertNotSame(complex0, complex17);
assertSame(complex0, complex7);
assertNotSame(complex0, complex8);
assertNotSame(complex0, complex9);
assertNotSame(complex0, complex18);
assertNotSame(complex0, complex5);
assertNotSame(complex13, complex18);
assertNotSame(complex13, complex7);
assertNotSame(complex13, complex12);
assertNotSame(complex13, complex11);
assertNotSame(complex13, complex4);
assertNotSame(complex13, complex16);
assertNotSame(complex13, complex17);
assertNotSame(complex13, complex2);
assertNotSame(complex13, complex6);
assertNotSame(complex13, complex9);
assertNotSame(complex13, complex10);
assertNotSame(complex13, complex1);
assertNotSame(complex13, complex15);
assertNotSame(complex13, complex8);
assertNotSame(complex13, complex3);
assertNotSame(complex13, complex19);
assertNotSame(complex13, complex5);
assertNotSame(complex13, complex14);
assertNotSame(complex13, complex0);
Complex complex20 = complex7.subtract(0.0);
assertFalse(complex20.equals((Object)complex15));
assertTrue(complex20.equals((Object)complex17));
assertFalse(complex20.equals((Object)complex10));
assertFalse(complex20.equals((Object)complex16));
assertFalse(complex20.equals((Object)complex9));
assertFalse(complex20.equals((Object)complex3));
assertFalse(complex20.equals((Object)complex12));
assertFalse(complex20.equals((Object)complex2));
assertFalse(complex20.equals((Object)complex5));
assertFalse(complex20.equals((Object)complex11));
assertFalse(complex20.equals((Object)complex6));
assertTrue(complex20.equals((Object)complex0));
assertFalse(complex20.equals((Object)complex8));
assertFalse(complex20.equals((Object)complex19));
assertFalse(complex20.equals((Object)complex18));
assertTrue(complex20.equals((Object)complex14));
assertTrue(complex20.equals((Object)complex13));
assertTrue(complex20.equals((Object)complex7));
assertFalse(complex20.equals((Object)complex4));
assertFalse(complex20.equals((Object)complex1));
assertFalse(complex7.equals((Object)complex5));
assertFalse(complex7.equals((Object)complex18));
assertFalse(complex7.equals((Object)complex6));
assertFalse(complex7.equals((Object)complex8));
assertTrue(complex7.equals((Object)complex14));
assertFalse(complex7.equals((Object)complex12));
assertFalse(complex7.equals((Object)complex19));
assertFalse(complex7.equals((Object)complex11));
assertTrue(complex7.equals((Object)complex17));
assertFalse(complex7.equals((Object)complex10));
assertFalse(complex7.equals((Object)complex1));
assertTrue(complex7.equals((Object)complex13));
assertFalse(complex7.equals((Object)complex3));
assertFalse(complex7.equals((Object)complex9));
assertFalse(complex7.equals((Object)complex4));
assertFalse(complex7.equals((Object)complex2));
assertFalse(complex7.equals((Object)complex16));
assertFalse(complex7.equals((Object)complex15));
assertNotNull(complex20);
assertFalse(complex20.isInfinite());
assertFalse(complex20.isNaN());
assertEquals(1.0, complex20.getReal(), 0.01);
assertEquals(0.0, complex20.getImaginary(), 0.01);
assertFalse(complex7.isNaN());
assertEquals(1.0, complex7.getReal(), 0.01);
assertEquals(0.0, complex7.getImaginary(), 0.01);
assertFalse(complex7.isInfinite());
assertNotSame(complex20, complex15);
assertNotSame(complex20, complex14);
assertNotSame(complex20, complex10);
assertNotSame(complex20, complex16);
assertNotSame(complex20, complex9);
assertNotSame(complex20, complex3);
assertNotSame(complex20, complex12);
assertNotSame(complex20, complex2);
assertNotSame(complex20, complex5);
assertNotSame(complex20, complex0);
assertNotSame(complex20, complex11);
assertNotSame(complex20, complex6);
assertNotSame(complex20, complex8);
assertNotSame(complex20, complex7);
assertNotSame(complex20, complex19);
assertNotSame(complex20, complex18);
assertNotSame(complex20, complex4);
assertNotSame(complex20, complex13);
assertNotSame(complex20, complex17);
assertNotSame(complex20, complex1);
assertSame(complex7, complex0);
assertNotSame(complex7, complex5);
assertNotSame(complex7, complex18);
assertNotSame(complex7, complex20);
assertNotSame(complex7, complex6);
assertNotSame(complex7, complex8);
assertNotSame(complex7, complex12);
assertNotSame(complex7, complex19);
assertNotSame(complex7, complex11);
assertNotSame(complex7, complex10);
assertNotSame(complex7, complex13);
assertNotSame(complex7, complex1);
assertNotSame(complex7, complex3);
assertNotSame(complex7, complex14);
assertNotSame(complex7, complex17);
assertNotSame(complex7, complex9);
assertNotSame(complex7, complex4);
assertNotSame(complex7, complex2);
assertNotSame(complex7, complex16);
assertNotSame(complex7, complex15);
}
@Test(timeout = 4000)
public void test101() throws Throwable {
Complex complex0 = Complex.valueOf(747.4335024174);
complex0.getArgument();
complex0.getArgument();
complex0.NaN.asin();
Complex complex1 = complex0.createComplex(0.0, 6.980004387880031E-8);
complex1.I.hashCode();
complex1.getField();
Complex complex2 = complex0.subtract(747.4335024174);
Complex complex3 = complex2.ZERO.add(complex0);
complex2.NaN.getField();
complex2.I.pow((-635.181694));
complex2.multiply((-2278));
complex3.conjugate();
try {
complex2.nthRoot((-2278));
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// cannot compute nth root for null or negative n: -2,278
//
verifyException("org.apache.commons.math3.complex.Complex", e);
}
}
@Test(timeout = 4000)
public void test102() throws Throwable {
Complex complex0 = Complex.I;
complex0.NaN.hashCode();
Complex complex1 = complex0.I.pow(1032.42311);
Complex complex2 = complex0.divide(Double.NaN);
Complex complex3 = complex2.ONE.multiply(1);
Complex complex4 = complex3.INF.pow(complex2);
complex4.ONE.add((-1762.9777820431761));
complex1.ONE.hashCode();
Complex complex5 = complex1.cosh();
assertEquals(1.0818030347974272, complex5.getReal(), 0.01);
Complex complex6 = complex1.pow((double) 1);
Complex complex7 = complex2.sinh();
double double0 = complex3.abs();
assertEquals(1.0, double0, 0.01);
complex2.sinh();
Complex complex8 = complex7.cos();
complex7.getField();
complex0.cos();
Complex complex9 = complex3.createComplex(539.3, 1.0);
Complex complex10 = complex6.exp();
complex10.ZERO.add(260.39089047);
Complex complex11 = complex1.add((double) 1);
Complex complex12 = complex11.NaN.sqrt1z();
Complex complex13 = complex12.ONE.sinh();
assertEquals(0.0, complex13.getImaginary(), 0.01);
assertEquals(1.1752011936438014, complex13.getReal(), 0.01);
complex9.add(539.3);
Complex complex14 = complex3.subtract(complex12);
Complex complex15 = complex3.conjugate();
assertSame(complex2, complex14);
assertEquals(1.0, complex15.getReal(), 0.01);
Complex complex16 = complex6.asin();
assertNotSame(complex0, complex8);
assertEquals(0.6167597715741164, complex1.getImaginary(), 0.01);
assertEquals(0.6675502949828473, complex16.getReal(), 0.01);
}
}
| [
"pderakhshanfar@serg2.ewi.tudelft.nl"
] | pderakhshanfar@serg2.ewi.tudelft.nl |
e0058431d2e044a09902049d974c7da60fd55a9d | 3130765f287269f474dde937930a6adc00f0806a | /src/main/java/net/minecraft/server/aai.java | 983c6b30171ef8d2dbdda01719fd4b9a8880aeee | [] | no_license | airidas338/mc-dev | 928e105789567d1f0416028f1f0cb75a729bd0ec | 7b23ae7f3ba52ba8405d14cdbfed8da9f5f7092a | refs/heads/master | 2016-09-05T22:12:23.138874 | 2014-09-26T03:57:07 | 2014-09-26T03:57:07 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,380 | java | package net.minecraft.server;
public class aai extends zf {
private int e;
private EntityVillager f;
public aai(EntityVillager var1) {
super(var1, EntityVillager.class, 3.0F, 0.02F);
this.f = var1;
}
public void c() {
super.c();
if(this.f.cq() && this.b instanceof EntityVillager && ((EntityVillager)this.b).cr()) {
this.e = 10;
} else {
this.e = 0;
}
}
public void e() {
super.e();
if(this.e > 0) {
--this.e;
if(this.e == 0) {
wa var1 = this.f.co();
for(int var2 = 0; var2 < var1.n_(); ++var2) {
ItemStack var3 = var1.a(var2);
ItemStack var4 = null;
if(var3 != null) {
Item var5 = var3.getItem();
int var6;
if((var5 == Items.BREAD || var5 == Items.bS || var5 == Items.bR) && var3.count > 3) {
var6 = var3.count / 2;
var3.count -= var6;
var4 = new ItemStack(var5, var6, var3.getData());
} else if(var5 == Items.WHEAT && var3.count > 5) {
var6 = var3.count / 2 / 3 * 3;
int var7 = var6 / 3;
var3.count -= var6;
var4 = new ItemStack(Items.BREAD, var7, 0);
}
if(var3.count <= 0) {
var1.a(var2, (ItemStack)null);
}
}
if(var4 != null) {
double var11 = this.f.t - 0.30000001192092896D + (double)this.f.aR();
EntityItem var12 = new EntityItem(this.f.o, this.f.s, var11, this.f.u, var4);
float var8 = 0.3F;
float var9 = this.f.aI;
float var10 = this.f.z;
var12.v = (double)(-MathHelper.sin(var9 / 180.0F * 3.1415927F) * MathHelper.cos(var10 / 180.0F * 3.1415927F) * var8);
var12.x = (double)(MathHelper.cos(var9 / 180.0F * 3.1415927F) * MathHelper.cos(var10 / 180.0F * 3.1415927F) * var8);
var12.w = (double)(-MathHelper.sin(var10 / 180.0F * 3.1415927F) * var8 + 0.1F);
var12.p();
this.f.o.addEntity((Entity)var12);
break;
}
}
}
}
}
}
| [
"sam.sun469@gmail.com"
] | sam.sun469@gmail.com |
697b10ffe395d9b1a403a8bc39596132ff4f7978 | 43bde5b72aad825a9ade9104ced076b2bd9813be | /PhoneSecure/src/com/khanhtq/phonesecurity/activities/T2_ConversionMessage.java | c13fcd8914274cf37f2d37c23d215c60d8d2e296 | [] | no_license | Tran-Hong-Sang/phone-secure | 45367099281d66a97ab69ae9a7c03f59e8619beb | 2de31a7d2c4321adf230e1504c79015a9be1096e | refs/heads/master | 2021-05-27T20:56:59.823173 | 2014-07-25T06:14:52 | 2014-07-25T06:14:52 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,047 | java | package com.khanhtq.phonesecurity.activities;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;
import com.khanhtq.phonesecurity.R;
import com.khanhtq.phonesecurity.adapters.T2_AdapterForConversationList;
import com.khanhtq.phonesecurity.models.Message;
import com.khanhtq.phonesecurity.utils.T2_ContactUtils;
import com.khanhtq.phonesecurity.utils.T2_SMSUtility;
import com.khanhtq.phonesecurity.utils.T2_SQLiteUtility;
import com.khanhtq.phonesecurity.utils.T2_Singleton;
public class T2_ConversionMessage extends Activity implements OnClickListener {
ListView list;
Button send;
Context context;
ArrayList<Message> data;
T2_AdapterForConversationList adapter;
EditText bodyContent;
public static T2_ConversionMessage _this;
public void doWithReceivedMessages(Message[] msgs) {
List<Message> array = Arrays.asList(msgs);
for(Message m: array){
if(!T2_ContactUtils.getOriginalAddress(m.getAddress())
.equals(T2_ContactUtils.getOriginalAddress(T2_Singleton.currentMessageForConversation.getAddress()))){
array.remove(m);
}
}
data.addAll(data.size(), array);
adapter.notifyDataSetChanged();
list.setSelection(adapter.getCount() - 1);
}
// T2_SMSListener listener;
public T2_ConversionMessage(){
// listener = new T2_SMSListener() {
// @Override
// public void doWithReceivedMessages(Message[] msgs) {
// List<Message> array = Arrays.asList(msgs);
// for(Message m: array){
// if(!T2_ContactUtils.getOriginalAddress(m.getAddress())
// .equals(T2_ContactUtils.getOriginalAddress(T2_Singleton.currentMessageForConversation.getAddress()))){
// array.remove(m);
// }
// }
// data.addAll(data.size(), array);
// adapter.notifyDataSetChanged();
// list.setSelection(adapter.getCount() - 1);
// }
// };
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
_this = this;
setContentView(R.layout.t2_conversion);
setTitle(T2_Singleton.currentMessageForConversation.getFrom() == null || T2_Singleton.currentMessageForConversation.getFrom() .equals("")? T2_Singleton.currentMessageForConversation.getAddress() : T2_Singleton.currentMessageForConversation.getFrom());
context = getApplicationContext();
list = (ListView) findViewById(R.id.listView_chat);
send = (Button) findViewById(R.id.t2_conversation_send);
send.setOnClickListener(this);
bodyContent = (EditText) findViewById(R.id.t2_conversation_msgbody);
data = new ArrayList<Message>();
T2_SQLiteUtility dbU = new T2_SQLiteUtility(this).open("readDB");
data = dbU.getMessagesOfConversation(T2_Singleton.currentMessageForConversation.getAddress());
dbU.close();
adapter = new T2_AdapterForConversationList(this, data);
list.setAdapter(adapter);
list.setSelection(adapter.getCount() - 1);
}
@Override
public void onClick(View v) {
if (send == v) {
String address = T2_Singleton.currentMessageForConversation.getAddress();
String body = bodyContent.getText().toString();
bodyContent.setText("");
Message sendingMsg = new Message();
sendingMsg.setAddress(address);
sendingMsg.setType(Message.TYPE_SENT);
sendingMsg.setBody(body);
T2_SMSUtility.sendMessage(sendingMsg, context);
sendingMsg.setDate(new Date().getTime());
data.add(data.size(),sendingMsg);
adapter.notifyDataSetChanged();
Toast.makeText(this, "Sent", Toast.LENGTH_SHORT).show();
}
}
@Override
public void onBackPressed() {
Intent i = new Intent(this, MainActivity.class);
T2_Singleton._bool = true;
startActivity(i);
finish();
}
}
| [
"minh.khuong1306@gmail.com"
] | minh.khuong1306@gmail.com |
ce3049b22ffacca4795cc7d2fca2f207ca03cb2f | d1a6d1e511df6db8d8dd0912526e3875c7e1797d | /genny_JavaWithoutLambdasApi21/applicationModule/src/main/java/applicationModulepackageJava2/Foo404.java | a581a61d7ef7c4ef9d5cef4867abbc8a16150784 | [] | no_license | NikitaKozlov/generated-project-for-desugaring | 0bc1443ab3ddc84cd289331c726761585766aea7 | 81506b3711004185070ca4bb9a93482b70011d36 | refs/heads/master | 2020-03-20T00:35:06.996525 | 2018-06-12T09:30:37 | 2018-06-12T09:30:37 | 137,049,317 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 346 | java | package applicationModulepackageJava2;
public class Foo404 {
public void foo0() {
new applicationModulepackageJava2.Foo403().foo5();
}
public void foo1() {
foo0();
}
public void foo2() {
foo1();
}
public void foo3() {
foo2();
}
public void foo4() {
foo3();
}
public void foo5() {
foo4();
}
}
| [
"nikita.e.kozlov@gmail.com"
] | nikita.e.kozlov@gmail.com |
3f7282b096dcea83bba20fbd3b03de9d1be5ae89 | 3f169749adceb8a84803c561467e391ef381d7d0 | /workspace/studySystem/src/persistence/PersistentT_2_0.java | 9ec2faffcf6a7a0b88b7fa84e2e3c3bf736e4867 | [] | no_license | Cryzas/FHDW2 | 969619012ad05f455d04dce0f3413f53cedd9351 | 8bc31d4072cc9ed7ddf86154cdf08f0f9a55454b | refs/heads/master | 2021-01-23T05:25:00.249669 | 2017-10-11T06:24:17 | 2017-10-11T06:24:17 | 86,296,546 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 190 | java | package persistence;
public interface PersistentT_2_0 extends PersistentGradesInThird, T_2_04Public {
public PersistentT_2_0 getThis() throws PersistenceException ;
}
| [
"jensburczyk96@gmail.com"
] | jensburczyk96@gmail.com |
0d9da7e30cdfa3a75aceef213acc4686e51299fa | dfc52ef0236dbd53a90583e90e1e60f1cb79b8de | /app/src/main/java/com/example/administrator/volleynewsclientapplication/videonews/activity/VideoNewsMainActivity.java | 236a2dc226bbafc01271ed7990fd0928d618b786 | [] | no_license | zxs592408339/VolleyNewsClientApplication | 2a83479f2c55d03073522e277965fbf2d330da6b | c22b1d7bed4333519a0cdc7334501e0c46f09ae8 | refs/heads/master | 2020-12-03T06:59:14.824042 | 2016-08-19T09:11:51 | 2016-08-19T09:11:51 | 66,069,658 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,314 | java | package com.example.administrator.volleynewsclientapplication.videonews.activity;
import android.graphics.Color;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentStatePagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import com.example.administrator.volleynewsclientapplication.R;
import com.example.administrator.volleynewsclientapplication.videonews.fragment.VideoNewsFragment;
public class VideoNewsMainActivity extends AppCompatActivity implements ViewPager.OnPageChangeListener, View.OnClickListener {
private ViewPager mVideoNewsViewPager;
private TextView mNewsHotVideoTxt,mNewsRecreationVideoTxt,mNewsFunnyVideoTxt,mNewsQualityVideoTxt;
private ImageView mVideoTitleImg;
private String[] video_type_id = {"V9LG4B3A0", "V9LG4CHOR", "V9LG4E6VR", "00850FRB"};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_video_news_main);
mNewsHotVideoTxt = (TextView) findViewById(R.id.news_hot_video);
mNewsRecreationVideoTxt = (TextView) findViewById(R.id.news_recreation_video);
mNewsFunnyVideoTxt = (TextView) findViewById(R.id.news_funny_video);
mNewsQualityVideoTxt = (TextView) findViewById(R.id.news_quality_video);
mVideoTitleImg = (ImageView) findViewById(R.id.video_news_title);
mVideoTitleImg.setOnClickListener(this);
mNewsHotVideoTxt.setOnClickListener(this);
mNewsRecreationVideoTxt.setOnClickListener(this);
mNewsFunnyVideoTxt.setOnClickListener(this);
mNewsQualityVideoTxt.setOnClickListener(this);
mNewsHotVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsHotVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
mVideoNewsViewPager = (ViewPager) findViewById(R.id.video_news_view_pager);
mVideoNewsViewPager.addOnPageChangeListener(this);
VideoNewsAdapter adapter = new VideoNewsAdapter(getSupportFragmentManager());
mVideoNewsViewPager.setAdapter(adapter);
adapter.setData(video_type_id);
}
@Override
public void onClick(View view) {
clearBackgroundColor();
switch (view.getId()){
case R.id.news_hot_video:
mVideoNewsViewPager.setCurrentItem(0);
mNewsHotVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsHotVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case R.id.news_recreation_video:
mVideoNewsViewPager.setCurrentItem(1);
mNewsRecreationVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsRecreationVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case R.id.news_funny_video:
mVideoNewsViewPager.setCurrentItem(2);
mNewsFunnyVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsFunnyVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case R.id.news_quality_video:
mVideoNewsViewPager.setCurrentItem(3);
mNewsQualityVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsQualityVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case R.id.video_news_title:
finish();
break;
}
}
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
@Override
public void onPageSelected(int position) {
clearBackgroundColor();
switch (position) {
case 0:
mNewsHotVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsHotVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case 1:
mNewsRecreationVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsRecreationVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case 2:
mNewsFunnyVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsFunnyVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
case 3:
mNewsQualityVideoTxt.setBackgroundResource(R.drawable.btn_common_pressed);
mNewsQualityVideoTxt.setTextColor(getResources().getColor(R.color.colorWhite));
break;
}
}
@Override
public void onPageScrollStateChanged(int state) {
}
public void clearBackgroundColor() {
mNewsHotVideoTxt.setBackgroundColor(Color.TRANSPARENT);
mNewsRecreationVideoTxt.setBackgroundColor(Color.TRANSPARENT);
mNewsFunnyVideoTxt.setBackgroundColor(Color.TRANSPARENT);
mNewsQualityVideoTxt.setBackgroundColor(Color.TRANSPARENT);
mNewsHotVideoTxt.setTextColor(getResources().getColor(R.color.colorHui));
mNewsRecreationVideoTxt.setTextColor(getResources().getColor(R.color.colorHui));
mNewsFunnyVideoTxt.setTextColor(getResources().getColor(R.color.colorHui));
mNewsQualityVideoTxt.setTextColor(getResources().getColor(R.color.colorHui));
}
class VideoNewsAdapter extends FragmentStatePagerAdapter {
String[] video_type_id = new String[]{};
public VideoNewsAdapter(FragmentManager fm) {
super(fm);
}
public void setData(String[] video_type_id) {
this.video_type_id = video_type_id;
notifyDataSetChanged();
}
@Override
public Fragment getItem(int position) {
return VideoNewsFragment.newInstance(video_type_id[position]);
}
@Override
public int getCount() {
return video_type_id.length;
}
}
}
| [
"592408339@qq.com"
] | 592408339@qq.com |
b70ae4b24d1fd07dae1f2cc576203e7272c6f37c | d210d3c93368047dcf8130fef5b4582fe086fb64 | /RabbitMQ/01_pattern/src/main/java/com/github/Producer.java | ead85e96daf0f3170256ada87014ee91e829ec2a | [] | no_license | andochiwa/Message-Middleware-Notes | d3933c227b83aeb57c4563b0b5246d1b8e740cb6 | 61dab4e65a85763119fcaafe7f411fff3d3b4a69 | refs/heads/master | 2023-06-23T20:19:35.539257 | 2021-07-27T13:49:31 | 2021-07-27T13:49:31 | 347,689,595 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 2,358 | java | package com.github;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import lombok.SneakyThrows;
/**
* @author HAN
* @version 1.0
* @create 03-19-3:16
*/
public class Producer {
private static final String QUEUE_NAME = "queue01";
@SneakyThrows
public static void main(String[] args){
// 1.ๅๅปบ่ฟๆฅๅทฅ็จ๏ผ่ฎพ็ฝฎipๅport่ฟๆ่ดฆๅทๅฏ็
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
// 2.ๅๅปบ่ฟๆฅConnection
Connection connection = connectionFactory.newConnection("producer");
// 3.้่ฟ่ฟๆฅ่ทๅ้้Channel
Channel channel = connection.createChannel();
// 4.ๅๅคๆถๆฏๅ
ๅฎน
String message = "hello world";
// 5.ๅๅคไบคๆขๆบ๏ผ่ทฏ็ฑkey๏ผ็ฑปๅ
String exchangeName = "direct_message_exchange";
String routeKey = "order";
// ไบคๆขๆบ็ฑปๅ direct/topic/fanout/headers
String exchangeType = "direct";
// 6.ๅฃฐๆไบคๆขๆบ๏ผ็ฌฌไธไธชๅๆฐไธบๆฏๅฆๆไน
ๅ๏ผๅณไบคๆขๆบไผไธไผ้ๆๅกๅจ้ๅฏ่้ ๆไธขๅคฑ
channel.exchangeDeclare(exchangeName, exchangeType, true);
// 7. ๅฃฐๆ้ๅ
channel.queueDeclare("queue5", true, false, false, null);
channel.queueDeclare("queue6", true, false, false, null);
channel.queueDeclare("queue7", true, false, false, null);
channel.queueDeclare("queue8", true, false, false, null);
// 8.็ปๅฎ้ๅ
channel.queueBind("queue5", exchangeName, "order");
channel.queueBind("queue6", exchangeName, "course");
channel.queueBind("queue7", exchangeName, "order");
channel.queueBind("queue8", exchangeName, "course");
// 9.ๅ้ๆถๆฏ
// ๅๆฐ๏ผ1.ไบคๆขๆบ 2.้ๅๅ/่ทฏ็ฑkey 3.ๆถๆฏ็็ถๆๆงๅถ 4.ๆถๆฏไธป้ข
channel.basicPublish(exchangeName, routeKey, null, message.getBytes());
System.out.println("ๅ้ๆๅ");
// 10.ๅ
ณ้ญๆๆ่ตๆบ
channel.close();
connection.close();
}
}
| [
"a1066079469@gmail.com"
] | a1066079469@gmail.com |
19200be71aec0a5770bd75a99160291fc5579d32 | 066ac725a5cd55b58995e3ca2e901540aee78e4a | /clientStore/src/controllers/ProductController.java | 229b77b1117b0e9cfd16ecffea299ecf4f70151a | [] | no_license | andreyPromaster/ComputerStore | b99053ccedcd222a0e670fd6583715bee4e3ff7e | 681f439c3c47ad683d1e87e43887aec9fe6df773 | refs/heads/main | 2023-01-30T21:55:06.526529 | 2020-12-15T22:12:53 | 2020-12-15T22:12:53 | 321,800,557 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 11,965 | java | package controllers;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.input.MouseEvent;
import javafx.stage.Modality;
import javafx.stage.Stage;
import model.*;
import java.io.IOException;
import java.net.URL;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Date;
import java.util.ResourceBundle;
import java.util.logging.XMLFormatter;
public class ProductController extends BaseController implements Initializable, ISetUser{
@FXML
private TableView<Nomeclature> TableProduct;
@FXML
private TableColumn<Nomeclature, Integer> ColumnID;
@FXML
private TableColumn<Nomeclature, String> ColumnArticle;
@FXML
private TableColumn<Nomeclature, String> ColumnName;
@FXML
private TableColumn<Nomeclature, String> ColumnDescription;
@FXML
private TableColumn<Nomeclature, String> ColumnComment;
@FXML
private ComboBox<CategoryProduct> CategoryProductList;
@FXML
private TextField FieldFind;
@FXML
private ComboBox CategoryProductListFind;
@FXML
void onBntChange(ActionEvent event) {
editProduct();
}
@FXML
void onBtnDelete(ActionEvent event) {
deleteProduct();
}
@FXML
void onBtnNew(ActionEvent event) {
saveProduct();
}
private ObservableList<DocumentInfo> documentlist;
private User user;
public void setModelUser(User user){
this.user = user;
}
private void setDocumentlist(ObservableList<DocumentInfo> list){
this.documentlist = list;
}
public ObservableList<DocumentInfo> getDocumentlist() {
return documentlist;
}
@Override
public void initialize(URL url, ResourceBundle resourceBundle) {
refreshTable();
refreshTableDocument();
initListCategoryProduct(CategoryProductList);
initListTypeDocument(FilterTypeDocument);
initTableDocumentContent();
}
private void initTable() {
ColumnID.setCellValueFactory(new PropertyValueFactory<>("idNomeclature"));
ColumnArticle.setCellValueFactory(new PropertyValueFactory<>("article"));
ColumnName.setCellValueFactory(new PropertyValueFactory<>("name"));
ColumnDescription.setCellValueFactory(new PropertyValueFactory<>("description"));
ColumnComment.setCellValueFactory(new PropertyValueFactory<>("comment"));
}
private void refreshTable() {
initTable();
client.sendMessage(Commands.GET_ALL_PRODUCT.toString());
ObservableList<Nomeclature> list = FXCollections.observableArrayList((ArrayList<Nomeclature>)client.readObject());
TableProduct.setItems(list);
}
private void initListCategoryProduct(ComboBox<CategoryProduct> listbox){
listbox.getSelectionModel().clearSelection();
client.sendMessage(Commands.GET_ALL_CATEGORY.toString());
ObservableList<CategoryProduct> list = FXCollections.observableArrayList((ArrayList<CategoryProduct>)client.readObject());
listbox.setItems(list);
listbox.getSelectionModel().select(0);
}
public void initChildrenSceneList(ComboBox<CategoryProduct> listbox){
initListCategoryProduct(listbox);
}
public void refreshTableFromChildrenScene(){
refreshTable();
}
private void deleteProduct() {
Nomeclature selected = TableProduct.getSelectionModel().getSelectedItem();
if(selected != null){
int Id = selected.getIdNomeclature();
client.sendMessage(Commands.DELETE_PRODUCT.toString());
client.sendObject(Id);
refreshTable();
} else {
warningAlert("ะัะธะฑะบะฐ","ะัะฑะตัะธัะต ะทะฐะฟะธัั");
}
}
private void editProduct() { // for updating existing product
Nomeclature selected = TableProduct.getSelectionModel().getSelectedItem();
if(selected != null){
showEditFormProduct( selected, false);
} else {
warningAlert("ะัะธะฑะบะฐ","ะัะฑะตัะธ ะทะฐะฟะธัั ะดะปั ะธะทะผะตะฝะตะฝะธั");
}
}
private void saveProduct(){
showEditFormProduct(null, true);
}
public void onListFilter(ActionEvent event) {
initTable();
client.sendMessage(Commands.FILTER_PRODUCT_BY_CATEGORY.toString());
client.sendObject(CategoryProductList.getSelectionModel().getSelectedItem().getIdCategory());
ObservableList<Nomeclature> list = FXCollections.observableArrayList((ArrayList<Nomeclature>)client.readObject());
TableProduct.setItems(list);
}
private void showEditFormProduct(Nomeclature product, boolean command){
try {
FXMLLoader loader = new FXMLLoader(getClass().getResource("/sample/newChangeProduct.fxml"));
NewChangeProduct controller = new NewChangeProduct();
controller.setProduct(product);
controller.setSaveCommand(command);
controller.setMainController(this);
loader.setController(controller);
Parent root = loader.load();
Scene scene = new Scene(root);
Stage stage = new Stage();
stage.setScene(scene);
stage.initModality(Modality.APPLICATION_MODAL);
stage.show();
} catch (IOException e) {
e.printStackTrace();
}
}
public void onBntFind(ActionEvent event) {
client.sendMessage(Commands.FIND_PRODUCT_BY.toString());
client.sendObject(CategoryProductListFind.getSelectionModel().getSelectedIndex());
client.sendObject(FieldFind.getText());
initTable();
ObservableList<Nomeclature> list = FXCollections.observableArrayList((ArrayList<Nomeclature>)client.readObject());
TableProduct.setItems(list);
}
// next tab about documents
private void initTableDocument(){
ColumnIDDocument.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getDocument().getIdDocument()));
ColumnDatetime.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getDocument().getDate_time()));
ColumnTypeDocument.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getType().getName()));
ColumnUser.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getUser().getUsername()));
ColumnAgent.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getCustomer().getFull_name()));
ColumnStage.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getState().getName()));
}
private void refreshTableDocument(){
initTableDocument();
client.sendMessage(Commands.GET_ALL_INFO_DOCUMENT.toString());
ObservableList<DocumentInfo> list = FXCollections.observableArrayList((ArrayList<DocumentInfo>)client.readObject());
TableDocument.setItems(list);
setDocumentlist(list);
}
private void initTableDocumentContent(){
ColumnIDContent.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getContent().getIdContent()));
ColumnNameContent.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getProduct().getName()));
ColumnAmount.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getContent().getAmount()));
ColumnPrice.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper(cellData.getValue().getContent().getPrice()));
}
private void initListTypeDocument(ComboBox<DocumentType> listbox){
listbox.getSelectionModel().clearSelection();
client.sendMessage(Commands.GET_ALL_TYPE_DOCUMENT.toString());
ObservableList<DocumentType> list = FXCollections.observableArrayList((ArrayList<DocumentType>)client.readObject());
DocumentType type = new DocumentType();
type.setName("ะัะต ะบะฐัะตะณะพัะธะธ");
list.add(type);
listbox.setItems(list);
listbox.getSelectionModel().select(0);
}
@FXML
private TableView<DocumentInfo> TableDocument;
@FXML
private TableColumn<DocumentInfo, Integer> ColumnIDDocument;
@FXML
private TableColumn<DocumentInfo, String> ColumnDatetime;
@FXML
private TableColumn<DocumentInfo, String> ColumnTypeDocument;
@FXML
private TableColumn<DocumentInfo, String> ColumnUser;
@FXML
private TableColumn<DocumentInfo, String> ColumnAgent;
@FXML
private TableColumn<DocumentInfo, String> ColumnStage;
@FXML
private ComboBox<DocumentType> FilterTypeDocument;
@FXML
private DatePicker DateStart;
@FXML
private DatePicker DateEnd;
@FXML
private TableView<DocumentContentInfo> TableContentDocument;
@FXML
private TableColumn<DocumentContentInfo, Integer> ColumnIDContent;
@FXML
private TableColumn<DocumentContentInfo, String> ColumnNameContent;
@FXML
private TableColumn<DocumentContentInfo, Integer> ColumnAmount;
@FXML
private TableColumn<DocumentContentInfo, Double> ColumnPrice;
@FXML
void FilterListTypeDocument(ActionEvent event) {
if(FilterTypeDocument.getSelectionModel().getSelectedItem().getName().equals("ะัะต ะบะฐัะตะณะพัะธะธ")){
TableDocument.setItems(getDocumentlist());
}
else {
ObservableList<DocumentInfo> arr_filtered = getDocumentlist().filtered(item -> item.getType().getName().equals(
FilterTypeDocument.getSelectionModel().getSelectedItem().getName()));
TableDocument.setItems(arr_filtered);
}
}
@FXML
void OnBtnFilterDate(ActionEvent event) {
LocalDate start_date = DateStart.getValue();
LocalDate end_date = DateEnd.getValue();
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
if (start_date != null && end_date != null){
Date start = java.sql.Date.valueOf(start_date);
Date end = java.sql.Date.valueOf(end_date);
ObservableList<DocumentInfo> arr_filtered = getDocumentlist().filtered(item -> {
try {
Date temp_date = format.parse(item.getDocument().getDate_time());
return temp_date.after(start) && temp_date.before(end);
} catch (ParseException e) {
e.printStackTrace();
}
return false;
});
TableDocument.setItems(arr_filtered);
}else {
warningAlert("ะัะธะฑะบะฐ","ะะฒะตะดะธัะต ะดะฐัั");
}
}
public void onBtnUpdateDocument(ActionEvent event) {
refreshTableDocument();
}
public void GetInformationAboutDoc(MouseEvent mouseEvent) {
if(mouseEvent.getClickCount() == 1){
DocumentInfo info = TableDocument.getSelectionModel().getSelectedItem();
if(info != null){
client.sendMessage(Commands.GET_CONTEXT_DOCUMENT_BY_ID.toString());
client.sendObject(info.getDocument().getIdDocument());
ObservableList<DocumentContentInfo> list = FXCollections.observableArrayList((ArrayList<DocumentContentInfo>)client.readObject());
initTableDocumentContent();
TableContentDocument.setItems(list);
}
}
}
public void onBtnComeBack(ActionEvent event) {
goHomeScene(event, user);
}
}
| [
"and45.rew@ya.ru"
] | and45.rew@ya.ru |
b61729f4b1921527ba2b70144228b638a5c70f9e | a41484c2412361078431594757392afa946018d4 | /src/polymorphism/bindingTest2/BindingTest2.java | 03770dba5f5fb32ad0879769bfc79c6df2b2dc0d | [] | no_license | monkeyDugi/javaEssence | d281cbb67cc755177cf123afae09877000fc41e1 | 88216fdc42867defc2da4ca11f4b76a1cce550c6 | refs/heads/master | 2022-12-10T15:08:11.967011 | 2020-09-07T14:37:55 | 2020-09-07T14:37:55 | 287,302,223 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 892 | java | package polymorphism.bindingTest2;
// ์กฐ์, ์์์ ์ธ์คํด์ค ๋ณ์๋ฅผ ์ ํํ์ฌ ์ฌ์ฉํ๊ธฐ ์ํด์ super(์กฐ์), this(์์)์ ์ฌ์ฉํ๋ค.
public class BindingTest2 {
public static void main(String[] args) {
Parent p = new Child();
Child c = new Child();
System.out.println("p.x = " + p.x);
p.method();
System.out.println();
System.out.println("c.x = " + c.x);
c.method();
}
}
class Parent {
int x = 100;
void method() {
System.out.println("Parent Method");
}
}
class Child extends Parent {
int x = 200;
void method() {
System.out.println("x=" + x); // this.x์ ๊ฐ์
System.out.println("super.x=" + super.x); // ์กฐ์์ ์ธ์คํด์ค ๋ณ์ ์ฌ์ฉ
System.out.println("this.x=" + this.x); // ๋ ์์ ์ ์ธ์คํด์ค ๋ณ์ ์ฌ์ฉ
}
} | [
"lbd4946@gmail.com"
] | lbd4946@gmail.com |
352136bfbbbafe4ff17477eab85ceba8c928614f | a0abdf04905a0bbe2adc2f0539b1c4bb33321b11 | /week-07/day-03/day-3/src/main/java/com/greenfoxacademy/day3/services/RedColor.java | 8705457b69d37e443b46ebf674c6b0b19f883b02 | [] | no_license | green-fox-academy/ChriswellPetii | 6528376e3074f81ec8e05f1527dbe8ea8a8af43a | e3650fadd365809a6efdda6f5940f37e3c01117b | refs/heads/master | 2020-03-25T00:02:39.272400 | 2018-10-11T07:50:45 | 2018-10-11T07:50:45 | 143,166,338 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 302 | java | package com.greenfoxacademy.day3.services;
import com.greenfoxacademy.day3.interfaces.MyColor;
import org.springframework.stereotype.Service;
@Service
public class RedColor implements MyColor {
@Override
public void printColor() {
System.out.println("Its a red in color...");
}
}
| [
"nypeti13@gmail.com"
] | nypeti13@gmail.com |
8d331c1e086e320bc045ae10bcdab1a0c65d9d20 | 8262b899a5fc9ab28049c1ca890840c652b8a5c2 | /app/src/main/java/com/ibetter/www/adskitedigi/adskitedigi/settings/overlay_image_settings/OverlayImageSettings.java | bc3f4416bd4ba8071dfd88cb529e3592e5269d4f | [] | no_license | akdeveloper0791/ngl_player | 64540f89e9d58cef2d25d8866daf56444ec6a3ed | b3841f50405044ada89352cc200c6a60d3945e7e | refs/heads/master | 2021-07-22T09:25:06.698955 | 2021-01-06T04:30:29 | 2021-01-06T04:30:29 | 233,202,490 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 10,895 | java | package com.ibetter.www.adskitedigi.adskitedigi.settings.overlay_image_settings;
import android.app.ActionBar;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.util.Log;
import android.view.MenuItem;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Spinner;
import android.widget.Switch;
import android.widget.Toast;
import com.bumptech.glide.Glide;
import com.ibetter.www.adskitedigi.adskitedigi.R;
import com.ibetter.www.adskitedigi.adskitedigi.model.Constants;
import com.ibetter.www.adskitedigi.adskitedigi.model.GalleryMediaModel;
import com.ibetter.www.adskitedigi.adskitedigi.settings.advance_settings.ScreenOrientationModel;
import org.json.JSONObject;
import java.io.File;
public class OverlayImageSettings extends Activity {
private OverlayImageSettingsModel overlayImageSettingsModel;
private Context context;
private LinearLayout settingsInfoLayout;
public final static int IMAGE_ACTION=1716;
private ImageView overlayImageView;
private String imagePath;
private Spinner positionTypeSpinner;
private EditText widthET,heightET;
private ArrayAdapter<CharSequence> adapter;
@Override
protected void onCreate( Bundle savedInstanceState) {
setRequestedOrientation(ScreenOrientationModel.getSelectedScreenOrientation(this));
super.onCreate(savedInstanceState);
setContentView(R.layout.overlay_image_settings_layout);
setActionBar();
context=OverlayImageSettings.this;
overlayImageSettingsModel=new OverlayImageSettingsModel();
settingsInfoLayout=findViewById(R.id.settings_info_layout);
overlayImageView=findViewById(R.id.overlaying_image);
positionTypeSpinner=findViewById(R.id.position_type_spinner);
widthET=findViewById(R.id.width);
heightET=findViewById(R.id.height);
setOverlayImageStatusSettingsSwitch();
setImagesSelection();
setPositionTypeSpinner();
setSettingsInfoValues();
saveInfo();
}
private void saveInfo()
{
findViewById(R.id.update).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if(validateFields())
{
try {
JSONObject jsonObject = new JSONObject();
jsonObject.put("width", widthET.getText().toString());
jsonObject.put("height", widthET.getText().toString());
jsonObject.put("position", positionTypeSpinner.getSelectedItem());
overlayImageSettingsModel.storeOverlayImageAndSettingsInfo(context,jsonObject.toString(),imagePath);
}catch (Exception E)
{
Toast.makeText(context,"Unable to save",Toast.LENGTH_SHORT).show();
}
}
}
});
}
private boolean validateFields()
{
boolean flag=true;
if(!new Constants().verifyTextLength(widthET.getText().toString(),1))
{
widthET.setError("Please enter width");
flag=false;
}
if(!new Constants().verifyTextLength(heightET.toString(),1))
{
heightET.setError("Please enter height");
flag=false;
}
if(!new Constants().verifyTextLength(imagePath,1))
{
Toast.makeText(context,"Please select image",Toast.LENGTH_SHORT).show();
flag=false;
}
if(positionTypeSpinner.getSelectedItemId()==0)
{
Toast.makeText(context,"Please select Position",Toast.LENGTH_SHORT).show();
flag=false;
}
return flag;
}
private void setSettingsInfoValues()
{
String settingsInfo=overlayImageSettingsModel.getOverlayingImageSettingsInfo(context);
try
{
JSONObject jsonObject = new JSONObject(settingsInfo);
widthET.setText(jsonObject.getString("width"));
heightET.setText(jsonObject.getString("height"));
String position=jsonObject.getString("position");
positionTypeSpinner.setSelection(adapter.getPosition(position),true);
}
catch (Exception E)
{
E.printStackTrace();
}
//setImage
imagePath=overlayImageSettingsModel.getOverlayingImagePath(context);
if(imagePath!=null)
{
if( new File(imagePath).exists()) {
findViewById(R.id.image_capture).setVisibility(View.GONE);
// Set the Image in ImageView after decoding the String
overlayImageView.setImageBitmap(BitmapFactory.decodeFile(imagePath));
}
}
}
private void setPositionTypeSpinner()
{
// Create an ArrayAdapter using the string array and a default spinner layout
adapter = ArrayAdapter.createFromResource(context,
R.array.overlay_image_position, android.R.layout.simple_spinner_item);
// Specify the layout to use when the list of choices appears
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
// Apply the adapter to the spinner
positionTypeSpinner.setAdapter(adapter);
}
//set action bar
private void setActionBar()
{
ActionBar actionBar = getActionBar();
actionBar.setDisplayShowTitleEnabled(true);
actionBar.setTitle("Overlaying Image Settings");
actionBar.setDisplayHomeAsUpEnabled(true);
}
private void setOverlayImageStatusSettingsSwitch()
{
Switch switchButton = (Switch)findViewById(R.id.setting_status);
//POS Item price Hide status update to server and save in Shared Preferance -- pos_item_price_hide_status
boolean status=overlayImageSettingsModel.getOverlayImageSettingStatus(context);
switchButton.setChecked(status);
if(status)
{
settingsInfoLayout.setVisibility(View.VISIBLE);
}
else
{
settingsInfoLayout.setVisibility(View.GONE);
}
switchButton.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener()
{
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked)
{
overlayImageSettingsModel.setOverlayImageSettingsStatus(context,isChecked);
if(isChecked)
{
settingsInfoLayout.setVisibility(View.VISIBLE);
}
else
{
settingsInfoLayout.setVisibility(View.GONE);
}
}
});
}
private void setImagesSelection()
{
findViewById(R.id.image_capture).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v)
{
getDefaultPhoto();
}
});
findViewById(R.id.overlaying_image).setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v)
{
getDefaultPhoto();
}
});
}
//set user profile photo
private void getDefaultPhoto()
{
Intent intent = new Intent();
intent.setType("image/*");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(Intent.createChooser(intent, "Pick Image"),IMAGE_ACTION);
//Intent galleryIntent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
//startActivityForResult(galleryIntent,IMAGE_ACTION);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data)
{
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode)
{
case android.R.id.home:
onBackPressed();
break;
case IMAGE_ACTION:
// When an Image is picked
if (resultCode == RESULT_OK && null != data)
{
// Get the Image from data
try {
Uri uri = data.getData();
if(uri!=null)
{
Glide.with(OverlayImageSettings.this)
.load(uri)
.into(overlayImageView);
// Set the Image in ImageView after decoding the String
// overlayImageView.setImageBitmap(BitmapFactory.decodeFile(imagePath));
findViewById(R.id.image_capture).setVisibility(View.GONE);
imagePath= new GalleryMediaModel(context).getPath(uri);
}else
{
Toast.makeText(context, "Please Select a Valid Image", Toast.LENGTH_SHORT).show();
}
/*String[] filePathColumn = { MediaStore.Images.Media.DATA };
// Get the cursor
Cursor cursor = context.getContentResolver().query(uri, filePathColumn, null, null, null);
// Move to first row
cursor.moveToFirst();
int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
imagePath = cursor.getString(columnIndex);
cursor.close();
Log.i("info","image Decodable String"+imagePath);*/
}catch (Exception e)
{
e.printStackTrace();
Toast.makeText(context, e.toString(), Toast.LENGTH_LONG).show();
}
} else
{
Toast.makeText(context, "You haven't picked Image", Toast.LENGTH_SHORT).show();
}
break;
}
}
public boolean onOptionsItemSelected(MenuItem item) {
// Take appropriate action for each action item click
switch (item.getItemId())
{
case android.R.id.home:
onBackPressed();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
}
| [
"vineethkumar0791@gmail.com"
] | vineethkumar0791@gmail.com |
72ae2c4f04bcea43550ce66c7daf50dbab931b7f | bc5f94d20a20d2bac1df74236be67c75bd4f14f6 | /app/src/test/java/com/svs/wt/tcpdebugtool/ExampleUnitTest.java | 6d27180f6ed5901bfb964636197df6f74f75785d | [] | no_license | wteaewt/TCPDebugTool | 96f711d74ae92dafac2c0fd3d932b01b945e2efc | 6d671945d753ca7c9b1e2bb412095b1a82799b84 | refs/heads/master | 2021-01-11T04:34:10.248859 | 2016-10-17T12:17:17 | 2016-10-17T12:17:17 | 71,134,724 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,953 | java | package com.svs.wt.tcpdebugtool;
import com.svs.wt.tcpdebugtool.helper.ByteHelper;
import com.svs.wt.tcpdebugtool.helper.CharHelper;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void charsToHexString_isCorrect() throws Exception {
char[] temps=new char[]{1,2,3,4,5};
String str=CharHelper.CharsToHexString(temps,temps.length,true);
assertEquals("01 02 03 04 05", str);
str=CharHelper.CharsToHexString(temps,temps.length,false);
assertEquals("0102030405", str);
}
@Test
public void HexStringToChars_isCorrect() throws Exception {
char[] temps=new char[]{1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5};
String str="0102030405010203040501020304050102030405";
char[] res=CharHelper.HexStringToChars(str);
assertEquals(String.valueOf(temps), String.valueOf(res));
}
@Test
public void bytesToHexString_isCorrect() throws Exception {
byte[] temps=new byte[]{1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5};
String str= ByteHelper.BytesToHexString(temps,temps.length,true);
assertEquals("01 02 03 04 05 01 02 03 04 05 01 02 03 04 05 01 02 03 04 05", str);
str=ByteHelper.BytesToHexString(temps,temps.length,false);
assertEquals("0102030405010203040501020304050102030405", str);
}
@Test
public void HexStringToBytes_isCorrect() throws Exception {
byte[] temps=new byte[]{1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5};
String str="01020304050102030405010203040501020304050102030405010203040501020304050102030405";
byte[] res=ByteHelper.HexStringToBytes(str);
assertEquals(new String(temps), new String(res));
}
} | [
"barbecuewang@163.com"
] | barbecuewang@163.com |
9c3ec4815963dfa81ddeaf2200c30ee523680d93 | 9200675af89121e19ccd3f6c63cb4ee2bea40c59 | /presentation/src/main/java/ir/fallahpoor/ca/featuredcategories/view/FeaturedCategoriesView.java | 67ae5b06b0d29537969e6831791590a39a875c6e | [] | no_license | MasoudFallahpour/CleanAndroidApp | 5a500e76c5a93f5a92090512a1eb126a47df0c77 | 9141bde19f7bdb6ac2ca5708bfed574ba9186dd5 | refs/heads/master | 2022-08-21T23:32:29.841044 | 2018-06-07T08:09:16 | 2018-06-07T08:09:16 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 404 | java | package ir.fallahpoor.ca.featuredcategories.view;
import com.hannesdorfmann.mosby3.mvp.MvpView;
import java.util.List;
import ir.fallahpoor.ca.featuredcategories.model.CategoryModel;
public interface FeaturedCategoriesView extends MvpView {
void showLoading();
void hideLoading();
void showRetry();
void hideRetry();
void renderCategories(List<CategoryModel> categories);
}
| [
"masood.fallahpoor@gmail.com"
] | masood.fallahpoor@gmail.com |
0ca18a1a808c541127b3cd70b675b83083a65842 | eb9bc1bf88374acbedd7e6d8fabf023a13ed28e7 | /03 ๆฐๆฎ็ปๆ/my-offer/src/com/todorex/offer3/SolutionBest.java | ba498abbc40b0e2378c503a47e9614028df80034 | [] | no_license | xinguohua/OfferFighting | 67851600cdc1843c78ba57d726d0223a06271308 | 59ccb143a248717880db0172853303ac596fe20a | refs/heads/master | 2023-01-03T11:23:58.614788 | 2020-10-27T01:26:58 | 2020-10-27T01:26:58 | 291,731,923 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,114 | java | package com.todorex.offer3;
import java.util.HashMap;
public class SolutionBest {
public int findRepeatNumber(int[] nums) {
// ๆ็ปๆฐ็ปไธบ็ฉบ
if (nums.length == 0) {
return -1;
}
// ๆ็ปๆฐ็ปๆ้ๆณๆฐๅญ
//ๆฐ็ป nums ้็ๆๆๆฐๅญ้ฝๅจ 0๏ฝn-1 ็่ๅดๅ
for (int i = 0; i < nums.length; i++) {
if (nums[i] < 0 || nums[i] > nums.length - 1) {
return -1;
}
}
for (int i = 0; i < nums.length; i++) {
//ๅฝๆซๆๅฐไธๆ ไธบi็ๆฐๅญ๏ผ้ฆๅ
ๆฏ่พ่ฟไธชๆฐๅญ๏ผ็จm่กจ็คบ๏ผๆฏไธๆฏ็ญไบi
while (nums[i] != i) {
//ๅฆๆๅ็ฌฌmไธชๆนๆณๆฐ็ป็ธ็ญ ๅณmไฝ็ฝฎๅiไฝ็ฝฎ็ธ็ญ๏ผๅญๅจ้ๅคๆฐๅญ่ฟๅ
if (nums[i] == nums[nums[i]]) {
nums[0] = nums[i];
return nums[0];
}
int temp = nums[i];
nums[i] = nums[temp];
nums[temp] = temp;
}
}
nums[0] = -1;
return nums[0];
}
}
| [
"794807072@qq.com"
] | 794807072@qq.com |
0470a97ac30b5b0683a53f42c9d2a739a8d60e39 | 9833fbea015933ee62056779b64d47637616402e | /src/main/java/com/cn/layui/sysadmin/service/UserManageService.java | 0ca76605d888384b32eee8410fae3a57278d3ed7 | [] | no_license | hl475689414/sys-admin | 263dbe211c575c2c370f3360277e1ba3c830603c | 6707a242cec52843b32bba462f3c9f33769a240f | refs/heads/master | 2020-03-27T19:26:29.294945 | 2018-09-15T10:27:30 | 2018-09-15T10:27:30 | 146,989,123 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,121 | java | package com.cn.layui.sysadmin.service;
import com.cn.layui.sysadmin.utils.JsonResult;
/**
* ็จๆท็ฎก็-ไธๅก้ป่พๅฑ
*/
public interface UserManageService {
/**
* ๅ้กต่ทๅ็จๆทๅ่กจ
* @param keys
* @param sex
* @param state
* @param isCompany
* @param curr ๅฝๅ้กต
* @param limit ๆฏ้กตๆฐๆฎๆกๆฐ
* @return
*/
JsonResult getCommonUserList(String keys, Integer sex, Integer state, Integer isCompany,Integer curr,Integer limit);
/**
* ้่ฟๆฅ่ฏขๆกไปถๆฅๆปๆกๆฐ
* @param keys
* @param sex
* @param state
* @param isCompany
* @return
*/
Integer selectCount(String keys, Integer sex, Integer state, Integer isCompany);
/**
* ่ทๅ็จๆทไฟกๆฏ
* @param userId
* @return
*/
JsonResult getUserInfo(Integer userId);
/**
* ่ทๅไธชไบบไฟกๆฏ
* @param userId
* @return
*/
JsonResult getPersonalUserInfo(Integer userId);
/**
* ่ทๅไผไธไฟกๆฏ
* @param userId
* @return
*/
JsonResult getCompanyUserInfo(Integer userId);
}
| [
"it77139@163.com"
] | it77139@163.com |
bee64b5ab1453dd383764df864140f3fcdfd5f46 | dc1dbb7e5a4b95bf44170d2f51fd08b3814f2ac9 | /data_defect4j/preprossed_method_corpus/Lang/6/org/apache/commons/lang3/tuple/MutableTriple_MutableTriple_74.java | 37bb47db7ffedf2734bbf587716d8731a6ba5361 | [] | no_license | hvdthong/NetML | dca6cf4d34c5799b400d718e0a6cd2e0b167297d | 9bb103da21327912e5a29cbf9be9ff4d058731a5 | refs/heads/master | 2021-06-30T15:03:52.618255 | 2020-10-07T01:58:48 | 2020-10-07T01:58:48 | 150,383,588 | 1 | 1 | null | 2018-09-26T07:08:45 | 2018-09-26T07:08:44 | null | UTF-8 | Java | false | false | 436 | java |
org apach common lang3 tupl
mutabl tripl consist code object element
thread safe threadsaf
param left element type
param middl element type
param element type
version
mutabl tripl mutabletripl tripl
creat tripl instanc
param left left
param middl middl
param
mutabl tripl mutabletripl left middl
left left
middl middl
| [
"hvdthong@gmail.com"
] | hvdthong@gmail.com |
680e84c2885aa8b9a9d987bcffac53bcadcad4bc | 2dba28e2015b1956015a723bb361877bac430986 | /SportyShoesEcommerce/src/main/java/com/service/UserValidity.java | f6ae294a4c645e134b0ec811f3ffe47bd582d6c3 | [] | no_license | mayu0112/SportyShoesEcommerce | dd1a3271dcd79488c8583b9cd2292758c9ba34f6 | 56e87b009f488437931326b19adb897c86310bd4 | refs/heads/main | 2023-04-30T21:34:50.711448 | 2021-05-21T08:18:07 | 2021-05-21T08:18:07 | 369,467,689 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,305 | java | package com.service;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.beans.Users;
import com.repository.UserDao;
@Service
public class UserValidity {
@Autowired
private UserDao userDao;
public boolean validateusers(String username, String pass) {
System.out.println("User Validity Service Reached");
Optional<Users> find = userDao.findById(username);
if (find.isPresent() && find.get().getPass().equals(pass)){
System.out.println("User is Valid: " + find.get().getName());
return true;
}
else {
return false;
}
}
public void addusers(String username, String pass, String email, String city) {
System.out.println("User Sign up Service Reached");
userDao.save(new Users(username, pass, email, city));
}
public List<Users> listUsers(){
List al = (ArrayList<Users>) userDao.findAll();
System.out.println("List of Users: " + al);
return al;
}
public Optional<Users> searchusers(String name) {
Optional<Users> find = userDao.findById(name);
System.out.println("Searched Users: " + find);
return find;
}
}
| [
"mahesh.chauhan@sabre.com"
] | mahesh.chauhan@sabre.com |
21aad4924b29dadd3823ae302850cbadef715280 | dd72bb3a8b5e6276b77b5964d2048d21dfa82463 | /server/src/by/epam/java_training/mihail_poliansky/final_project/command/jsp/JspLogoutCommand.java | f0ebd96a9e19c3d553da0d3b254b4248bf5f2426 | [] | no_license | MikleGod/DayManager | 02be1221d9f701a882d33d4a5525dc35868ce28f | 0c22bfc033e95b15a8e71b5dd90169422a35ad9b | refs/heads/master | 2020-03-23T11:07:58.051319 | 2018-08-27T16:15:13 | 2018-08-27T16:21:50 | 138,800,486 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 638 | java | package by.epam.java_training.mihail_poliansky.final_project.command.jsp;
import org.apache.logging.log4j.LogManager;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import static by.epam.java_training.mihail_poliansky.final_project.constant.JspPages.REGISTRATION_LOGIN_JSP;
public class JspLogoutCommand extends PageOpener {
@Override
public void execute(HttpServletRequest req, HttpServletResponse resp) {
req.getSession().invalidate();
LogManager.getLogger(JspLogoutCommand.class).info("forwarded");
dispatch(REGISTRATION_LOGIN_JSP, req, resp);
}
}
| [
"musical.hop@gmail.com"
] | musical.hop@gmail.com |
be9699d00b24ad3ca4643bee4aa199f28a441da1 | 27bdfc4dc396ab9cd2197694dcc26ae0a605284c | /src/main/java/com/gvendas/gestaovendas/excecao/RegraNegocioException.java | 8c019dac35f07a67ae69cd7474fe70520a0d6da5 | [] | no_license | alfredoesc/gestao-vendas | edf9abbb26d9c853cb1165123df9f91c6f1adfea | cf311aee5e5c284e37aebe46d37bc80a24ab0f16 | refs/heads/main | 2023-08-26T04:12:47.668441 | 2021-11-11T20:17:31 | 2021-11-11T20:17:31 | 423,561,109 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 230 | java | package com.gvendas.gestaovendas.excecao;
public class RegraNegocioException extends RuntimeException {
private static final long serialVersionUID = 1L;
public RegraNegocioException(String mensagem) {
super(mensagem);
}
}
| [
"alfredoesc@gmail.com"
] | alfredoesc@gmail.com |
c7f5c79be18631b26cd41b64214004988e5826fe | f649a211b624172f33e549dc04217066dd2f14d8 | /CouponApp/app/src/main/java/com/project/cs371/couponapp/RateLimit.java | 54cafa17c1d7ec2474d8712de6a711ad0feffde9 | [] | no_license | Samuely94/TopShop | e740b19a0f52b2edc2b960a186e4d51d418e382f | bf5e77945c9d0a239865127c8931f241ab60fae4 | refs/heads/master | 2021-01-22T06:27:54.934076 | 2017-02-12T22:50:17 | 2017-02-12T22:50:17 | 81,763,508 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,155 | java | package com.project.cs371.couponapp;
import android.os.Handler;
import java.util.LinkedList;
import java.util.concurrent.locks.ReentrantLock;
public class RateLimit {
public interface RateLimitCallback {
void rateLimitReady();
}
protected Handler handler;
protected Runnable rateLimitRequest;
protected final int rateLimitMillis = 1000; // 2 sec
protected ReentrantLock l = new ReentrantLock();
protected boolean okToRun;
protected LinkedList<RateLimitCallback> rateLimitCallbacks;
private RateLimit() {
handler = new Handler();
l = new ReentrantLock();
okToRun = false;
rateLimitCallbacks = new LinkedList<>();
rateLimitRequest = new Runnable() {
@Override
public void run() {
l.lock();
okToRun = true;
l.unlock();
runIfOk();
handler.postDelayed(this, rateLimitMillis);
}
};
handler.postDelayed(rateLimitRequest, rateLimitMillis);
}
protected void runIfOk() {
l.lock();
if (!rateLimitCallbacks.isEmpty() && okToRun) {
okToRun = false;
RateLimitCallback rlc = rateLimitCallbacks.pop();
l.unlock();
rlc.rateLimitReady();
return;
}
l.unlock();
}
private static class RateLimitHolder {
public static final RateLimit rateLimit = new RateLimit();
}
public static RateLimit getInstance() {
return RateLimitHolder.rateLimit;
}
public void add(RateLimitCallback rlc) {
l.lock();
try {
if (!rateLimitCallbacks.contains(rlc)) {
rateLimitCallbacks.add(rlc);
}
} finally {
l.unlock();
}
runIfOk();
}
public void addFront(RateLimitCallback rlc) {
l.lock();
try {
if (!rateLimitCallbacks.contains(rlc)) {
rateLimitCallbacks.push(rlc);
}
} finally {
l.unlock();
}
runIfOk();
}
}
| [
"noreply@github.com"
] | noreply@github.com |
8d69ba853cee1717ad153aebc7d71d7c498a06f2 | eca0527ac315b47e23b8c9a20a6c4b29330e1914 | /com.agit.brooks2.user.management/src/main/java/com/agit/brooks2/user/management/application/security/UserDetailsService.java | 37b821010751bd923f9ebb6387d7924440350cee | [] | no_license | bayuhendra/Project-Aspro---Brooks-2 | f051986516936750a50c63ad7bba14da6740eb52 | a087ceb55027744aae52ba894d38cbdae16b6d20 | refs/heads/master | 2020-12-30T10:49:26.294299 | 2017-08-16T04:25:42 | 2017-08-16T04:25:42 | 98,858,029 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,188 | java | package com.agit.brooks2.user.management.application.security;
import com.agit.brooks2.common.dto.usermanagement.UserDTO;
import com.agit.brooks2.common.security.UserDetailsImpl;
import com.agit.brooks2.shared.type.StatusData;
import com.agit.brooks2.user.management.application.RoleService;
import com.agit.brooks2.user.management.application.UserService;
import com.agit.brooks2.util.DateUtil;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.web.client.ResourceAccessException;
/**
*
* @author bayutridewanto
*
*/
public class UserDetailsService {
UserService userService;
RoleService roleService;
private final Integer MAX_ATTEMPTS = 3;
public UserDetailsImpl loadUserByUsername(String username) throws UsernameNotFoundException {
UserDTO user = null;
try {
user = userService.findByID(username.toLowerCase());
if (user.getUserName() == null) {
throw new UsernameNotFoundException("AvantradeSecurity.notFound");
}
} catch (ResourceAccessException e) {
/* if connection is refused */
throw new AuthenticationServiceException("AvantradeSecurity.connectionRefuse");
}
List<GrantedAuthority> authorities = SecurityCacheHelper.getAuthorities(user.getRoleDTO().getRoleID());
if (authorities == null) {
List<String> grantedAuthoritys = roleService.grantedAuthoritys(user.getRoleDTO().getRoleID());
authorities = grantedAuthorities(grantedAuthoritys);
SecurityCacheHelper.setAuthorities(user.getRoleDTO().getRoleID(), authorities);
}
boolean credentialsNonExpired = checkNonExpired(user.getUserSpecificationDTO().getUserLoginInfoDTO().getCredentialsExpiredDate());
boolean userNonLocked = user.getUserSpecificationDTO().getUserLoginInfoDTO().getLoginAttempt() < MAX_ATTEMPTS;
return new UserDetailsImpl(user.getUserName(), user.getPassword(), user.getUserStatus() == StatusData.ACTIVE, true, credentialsNonExpired, userNonLocked, authorities, user);
}
protected List<GrantedAuthority> grantedAuthorities(List<String> rolePrivilegeDTOs) {
List<GrantedAuthority> authorities = new ArrayList<>();
for (String auth : rolePrivilegeDTOs) {
authorities.add(new SimpleGrantedAuthority(auth));
}
return authorities;
}
protected boolean checkNonExpired(Date expiredDate) {
if (expiredDate == null) {
return true;
}
Date now = DateUtil.getDateWithoutTime(new Date());
return expiredDate.compareTo(now) > 0;
}
public void setUserService(UserService userService) {
this.userService = userService;
}
public void setRoleService(RoleService roleService) {
this.roleService = roleService;
}
}
| [
"bayuhendra1078@gmail.com"
] | bayuhendra1078@gmail.com |
71a0f8160043e19ff94eeabb27768335b1fefd06 | 52019a46c8f25534afa491a5f68bf5598e68510b | /core/metamodel/src/test/java/org/nakedobjects/metamodel/services/ServicesInjectorNoop.java | 48e9e4502a36e2483b47fdf3684875a46f243f62 | [
"Apache-2.0"
] | permissive | JavaQualitasCorpus/nakedobjects-4.0.0 | e765b4980994be681e5562584ebcf41e8086c69a | 37ee250d4c8da969eac76749420064ca4c918e8e | refs/heads/master | 2023-08-29T13:48:01.268876 | 2020-06-02T18:07:23 | 2020-06-02T18:07:23 | 167,005,009 | 0 | 1 | Apache-2.0 | 2022-06-10T22:44:43 | 2019-01-22T14:08:50 | Java | UTF-8 | Java | false | false | 865 | java | package org.nakedobjects.metamodel.services;
import java.util.List;
import org.nakedobjects.applib.DomainObjectContainer;
import org.nakedobjects.metamodel.commons.component.Noop;
public class ServicesInjectorNoop implements ServicesInjector, Noop {
public void open() {}
public void close() {}
public DomainObjectContainer getContainer() {
return null;
}
public void setContainer(DomainObjectContainer container) {}
public void setServices(List<Object> services) {}
public List<Object> getRegisteredServices() {
return null;
}
public void injectDependencies(Object domainObject) {}
public void injectDependencies(List<Object> objects) {}
public void injectInto(Object candidate) {}
}
// Copyright (c) Naked Objects Group Ltd.
| [
"taibi@sonar-scheduler.rd.tut.fi"
] | taibi@sonar-scheduler.rd.tut.fi |
760e381f9cd6eec119933610f86a0c3ccbd0889f | fbc8783d3d89a041d37fd67c098ef6d8c8f25a6e | /src/main/java/org/apache/clerezza/platform/content/PageNotFoundService.java | 431be809533247a02c2033968d63a44294295327 | [
"Apache-2.0"
] | permissive | clerezza/platform.content | 0a3d962e047fe17a4379a5ac9bc8e886e3ce04af | 92cb7579128bab812936b938b80436fbf74cb1f3 | refs/heads/master | 2021-01-11T08:33:06.608560 | 2016-10-04T12:01:53 | 2016-10-04T12:01:53 | 69,960,309 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,162 | java | /*
* Copyright 2010 reto.
*
* 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.
* under the License.
*/
package org.apache.clerezza.platform.content;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
/**
* An instance of this service is called by DiscoBitHandler if a resource
* is not found in the content graph.
*
* @author reto
*/
public interface PageNotFoundService {
/**
* Creates a response when a resource could not be found in the Content
* ImmutableGraph, this is a 404 response.
*
* @param uriInfo
* @return
*/
public Response createResponse(UriInfo uriInfo);
}
| [
"reto@apache.org"
] | reto@apache.org |
204bac2f5335bb85b6e09ae7362c117711b82191 | a40ef0eeee83abc258ab55c30f7a8450e78877f5 | /app/src/main/java/edu/uoc/orimarkettfm/ListProducts.java | e167a72119ca179fec2b2773099b24c62d1129e4 | [] | no_license | ajus17/orimarket | 58106f7054b944a648de0f6847cadbcfa72634ee | 60c05535d73b664105b0fd37efe352288efd9245 | refs/heads/main | 2023-05-31T18:27:54.811174 | 2021-07-05T19:43:12 | 2021-07-05T19:43:12 | 383,247,345 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 342 | java | package edu.uoc.orimarkettfm;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class ListProducts extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_list_products);
}
}
| [
"adolfoursa92@hotmail.com"
] | adolfoursa92@hotmail.com |
68460b7def9c6ef4e4a29cdfa1f89c8926805b85 | 2be9cb25039b3371755ed95d929f262f76dc01d9 | /src/test/java/org/alking/p1600/P1640Test.java | 878f3601d087a9ccb584444dabff3ca71455a211 | [] | no_license | aijingsun6/leetcode | d59c02dc300d28a465232d42829bb8f0259e2948 | 9e2eacdef6f33e1a9d73a7bcd1f8f65a285362e0 | refs/heads/master | 2022-06-11T09:08:38.228854 | 2022-06-05T04:21:26 | 2022-06-05T04:21:26 | 112,188,665 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 872 | java | package org.alking.p1600;
import org.junit.Assert;
import org.junit.Test;
public class P1640Test {
@Test
public void test() {
P1640 p1640 = new P1640();
int[] array = new int[]{15, 88};
int[][] pieces = new int[][]{
{88},
{15}
};
boolean result = p1640.canFormArray(array,pieces);
Assert.assertTrue(result);
array = new int[]{91,4,64,78};
pieces = new int[][]{
{78},
{4,64},
{91}
};
result = p1640.canFormArray(array,pieces);
Assert.assertTrue(result);
array = new int[]{1,3,5,7};
pieces = new int[][]{
{2},
{4,6},
{8}
};
result = p1640.canFormArray(array,pieces);
Assert.assertTrue(!result);
}
}
| [
"alking@alking.cc"
] | alking@alking.cc |
3355248cf6a516ed9ee3cf0f9f4bdd1ebe2fceae | 8b9190a8c5855d5753eb8ba7003e1db875f5d28f | /sources/com/google/common/escape/Escapers.java | f2fc75bd9805264a3af83d519d35515d7e465678 | [] | no_license | stevehav/iowa-caucus-app | 6aeb7de7487bd800f69cb0b51cc901f79bd4666b | e3c7eb39de0be6bbfa8b6b063aaa85dcbcee9044 | refs/heads/master | 2020-12-29T10:25:28.354117 | 2020-02-05T23:15:52 | 2020-02-05T23:15:52 | 238,565,283 | 21 | 3 | null | null | null | null | UTF-8 | Java | false | false | 4,810 | java | package com.google.common.escape;
import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.HashMap;
import java.util.Map;
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
@GwtCompatible
@Beta
public final class Escapers {
private static final Escaper NULL_ESCAPER = new CharEscaper() {
/* access modifiers changed from: protected */
public char[] escape(char c) {
return null;
}
public String escape(String str) {
return (String) Preconditions.checkNotNull(str);
}
};
private Escapers() {
}
public static Escaper nullEscaper() {
return NULL_ESCAPER;
}
public static Builder builder() {
return new Builder();
}
@Beta
public static final class Builder {
private final Map<Character, String> replacementMap;
private char safeMax;
private char safeMin;
/* access modifiers changed from: private */
public String unsafeReplacement;
private Builder() {
this.replacementMap = new HashMap();
this.safeMin = 0;
this.safeMax = 65535;
this.unsafeReplacement = null;
}
@CanIgnoreReturnValue
public Builder setSafeRange(char c, char c2) {
this.safeMin = c;
this.safeMax = c2;
return this;
}
@CanIgnoreReturnValue
public Builder setUnsafeReplacement(@NullableDecl String str) {
this.unsafeReplacement = str;
return this;
}
@CanIgnoreReturnValue
public Builder addEscape(char c, String str) {
Preconditions.checkNotNull(str);
this.replacementMap.put(Character.valueOf(c), str);
return this;
}
public Escaper build() {
return new ArrayBasedCharEscaper(this.replacementMap, this.safeMin, this.safeMax) {
private final char[] replacementChars;
{
this.replacementChars = Builder.this.unsafeReplacement != null ? Builder.this.unsafeReplacement.toCharArray() : null;
}
/* access modifiers changed from: protected */
public char[] escapeUnsafe(char c) {
return this.replacementChars;
}
};
}
}
static UnicodeEscaper asUnicodeEscaper(Escaper escaper) {
Preconditions.checkNotNull(escaper);
if (escaper instanceof UnicodeEscaper) {
return (UnicodeEscaper) escaper;
}
if (escaper instanceof CharEscaper) {
return wrap((CharEscaper) escaper);
}
throw new IllegalArgumentException("Cannot create a UnicodeEscaper from: " + escaper.getClass().getName());
}
public static String computeReplacement(CharEscaper charEscaper, char c) {
return stringOrNull(charEscaper.escape(c));
}
public static String computeReplacement(UnicodeEscaper unicodeEscaper, int i) {
return stringOrNull(unicodeEscaper.escape(i));
}
private static String stringOrNull(char[] cArr) {
if (cArr == null) {
return null;
}
return new String(cArr);
}
private static UnicodeEscaper wrap(final CharEscaper charEscaper) {
return new UnicodeEscaper() {
/* access modifiers changed from: protected */
public char[] escape(int i) {
if (i < 65536) {
return charEscaper.escape((char) i);
}
char[] cArr = new char[2];
Character.toChars(i, cArr, 0);
char[] escape = charEscaper.escape(cArr[0]);
char[] escape2 = charEscaper.escape(cArr[1]);
if (escape == null && escape2 == null) {
return null;
}
int length = escape != null ? escape.length : 1;
char[] cArr2 = new char[((escape2 != null ? escape2.length : 1) + length)];
if (escape != null) {
for (int i2 = 0; i2 < escape.length; i2++) {
cArr2[i2] = escape[i2];
}
} else {
cArr2[0] = cArr[0];
}
if (escape2 != null) {
for (int i3 = 0; i3 < escape2.length; i3++) {
cArr2[length + i3] = escape2[i3];
}
} else {
cArr2[length] = cArr[1];
}
return cArr2;
}
};
}
}
| [
"steve@havelka.co"
] | steve@havelka.co |
3c9217c62b8ad09fb74f0776c56bf385cb518d54 | 9cda96542a075b120637f7c91653ee82d06b459c | /src/com/sharma/algorithm/questions/FIFOQueueUsing2Stacks/Stack.java | be915814f886d5c97a30568e23a2593b96852113 | [] | no_license | jprvishal/Java | 755405ae6ce3b56d8741cb14dffcef418e4d6778 | c8c7f448b76d0247dfac28f30d88ff9816982c6a | refs/heads/master | 2020-08-12T02:36:06.596054 | 2019-11-26T04:45:24 | 2019-11-26T04:45:24 | 214,672,546 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 290 | java | package com.sharma.algorithm.questions.FIFOQueueUsing2Stacks;
public interface Stack {
final int MAX_ELEMENTS_SIZE = 20;
public Integer pop();
public Integer peep();
public boolean push(Integer element);
public int size();
public void printStack();
}
| [
"noreply@github.com"
] | noreply@github.com |
db40e5c3d470aab5fa29c9555c5886c939ab12e2 | cb44708d6df6883469ae315523e53f8c16aac8ce | /src/library/UtilesArray.java | 052ac5fba6ad92d628ff978c4d2b03ebd9d26dab | [
"LicenseRef-scancode-warranty-disclaimer",
"Apache-2.0"
] | permissive | RaulGB88/NetBeansJavaAppTemplate | e7a35eb4af79868ec0189f5bf7740ea26cd1915f | 7aae93214f9994a38a04b83a7fe702bdf8b0163a | refs/heads/master | 2020-12-24T05:38:40.085294 | 2017-06-20T04:43:21 | 2017-06-20T04:43:21 | 94,839,264 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,790 | java | /*
* Copyright 2017 (c) Raรบl Granel Blasco - raul.granel@gmail.com.
*
* 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 library;
import java.util.Random;
/**
*
* @author (c) Raรบl Granel Blasco - raul.granel@gmail.com
*/
public class UtilesArray {
// --------------------- LLENAR ARRAY ----------------------------
public static final Random RND = new Random(System.currentTimeMillis());
// Llenar el Array con valores Reales.
public static void llenarArrayAleatorioReal(double lista[], double min, double max) {
for (int i = 0; i < lista.length; i++) {
lista[i] = RND.nextDouble() * (max - min) + min;
}
}
// Llenar el Array con valores Enteros.
public static void llenarArrayAleatorioEntero(int lista[], int min, int max) {
for (int i = 0; i < lista.length; i++) {
lista[i] = RND.nextInt(max - min + 1) + min;
}
}
// --------------------- ACUMULAR ARRAY -------------------------
// Acumula los valores Reales con un for.
public static double sumarArrayReal(double[] lista) {
double acumulador = 0;
for (int i = 0; i < lista.length; i++) {
acumulador = acumulador + lista[i];
}
return acumulador;
}
// Acumula los valores Reales con un foreach.
public static double sumarArrayRealForEach(double[] lista) {
double acumulador = 0;
for (double item : lista) {
acumulador += item;
}
return acumulador;
}
public static Object[] sumarArrayReal() {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
// Acumula los valores Enteros con un for.
public static int sumarArrayEntero(int[] lista) {
int acumulador = 0;
for (int i = 0; i < lista.length; i++) {
acumulador = acumulador + lista[i];
}
return acumulador;
}
// --------------------------- BUSCAR ARRAY -------------------------------------
public static int buscarCaracterArray(char[] lista, char clave) {
boolean finalBusquedaOK = false;
int posicion = 0;
do {
if (lista[posicion] == clave) {
finalBusquedaOK = true;
} else if (posicion == lista.length - 1) {
finalBusquedaOK = true;
posicion = -1;
} else {
posicion++;
}
} while (!finalBusquedaOK);
return posicion;
}
public static int buscarEnteroArray(int[] lista, int numero) {
int posicion = -1;
for (int i = 0; i < lista.length; i++) {
if (numero == lista[i]) {
posicion = i;
}
}
return posicion;
}
// ------------------------------ DESORDENAR ARRAY ---------------------------
public static void desordenarArray(int[] lista) {
Random rnd = new Random(System.currentTimeMillis());
for (int i = 0; i < lista.length; i++) {
int aux = lista[i];
int posicion = rnd.nextInt(lista.length);
lista[i] = lista[posicion];
lista[posicion] = aux;
}
}
}
| [
"raul.granel@gmail.com"
] | raul.granel@gmail.com |
db412bb4bf8d2f8d89182a095c3d5c3efba01c0f | 86016b0f98c7443fc90a87d3a607dae4159db289 | /CoronayฤฑYakala/catchCorona/app/src/test/java/com/beratsafran/catchkenny/ExampleUnitTest.java | 6f761057e002243784b106bf437af1bce9ed7e01 | [] | no_license | bsafran/games | f68d88b75a09cb77de630b35268bb968dec9c324 | 073a72a8617fa5a040b5ae55a57eff7edb6be720 | refs/heads/master | 2022-04-25T20:40:32.544243 | 2020-04-29T19:43:18 | 2020-04-29T19:43:18 | 259,984,948 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 387 | java | package com.beratsafran.catchkenny;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() {
assertEquals(4, 2 + 2);
}
} | [
"beratsafran18@gmail.com"
] | beratsafran18@gmail.com |
f889fbefa3e66476e0131ed953ff3d6ca59e090f | 0b019f4cf840db8a6471c658425936fae96af8c0 | /src/Presentacion/Form_Proveedor.java | 07631b752fc9567ef3b481b96bca22992fd242e0 | [] | no_license | Yei-Linux/PharmacySystem-Java | e78d5bc9276058ae5ad40b79bd4e0c587707d7f9 | cdcfb584fd40cd2e12638691ec4b1f1edf6be646 | refs/heads/master | 2022-02-22T14:03:09.829601 | 2019-09-21T07:31:05 | 2019-09-21T07:31:05 | 209,930,222 | 0 | 0 | null | null | null | null | WINDOWS-1258 | Java | false | false | 15,819 | java | package Presentacion;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.table.DefaultTableModel;
import Datos.Datos_Producto;
import Datos.Datos_Proveedor;
import Logica.Metodo_form_Producto2;
import Logica.Metodo_form_Proveedor2;
import Logica.Metodo_form_trabajador;
import Logica.MiRender;
import Presentacion.Form_Producto.Lamina2_Form_Producto;
import Presentacion.Form_Producto.Lamina_Form_Producto;
public class Form_Proveedor extends JFrame{
public Container contentPane=new Container();
public Lamina_Form_Proveedor lamina=new Lamina_Form_Proveedor();
public Lamina2_Form_Proveedor lamina2=new Lamina2_Form_Proveedor();
public Form_Proveedor(){
setTitle("PROVEEDOR");
setSize(1250,650);
setLocationRelativeTo(null);
setResizable(false);
setContentPane(contentPane);
lamina.setBounds(50,50,550,530);
lamina.setBackground(new Color(52,73,94));
lamina.setBorder(BorderFactory.createMatteBorder(5,5,5,5,Color.BLACK));
lamina2.setBounds(650,50,550,530);
lamina2.setBackground(new Color(52,73,94));
lamina2.setBorder(BorderFactory.createMatteBorder(5,5,5,5,Color.BLACK));
contentPane.add(lamina);
contentPane.add(lamina2);
lamina2.Mostrar("");
lamina.Deshabilitar();
}
//PRIMERA LAMINA PARA REGISTRAR O EDITAR CLIENTES
class Lamina_Form_Proveedor extends JPanel{
public String accion="Guardar";
public ImageIcon imagen=new ImageIcon("src/Files/bola1.png");
public Accion_Button nuevo=new Accion_Button("Nuevo",new ImageIcon("src/Files/nuevo.png"));
public Accion_Button guardar=new Accion_Button("Guardar",new ImageIcon("src/Files/guardar.png"));
public Accion_Button cancelar=new Accion_Button("Cancelar",new ImageIcon("src/Files/borrar.png"));
public JLabel L_Titulo=new JLabel("REGISTRO PROVEEDOR");
public JLabel L_Nom_Proveedor=new JLabel("Proveedor");
public JLabel L_Direccion=new JLabel("Direccion");
public JLabel L_Celular=new JLabel("Celular");
public JLabel L_Distrito=new JLabel("Distrito");
public JTextField id_Proveedor=new JTextField(10);
public JTextField Nom_Proveedor=new JTextField(10);
public JTextField Celular=new JTextField(10);
public JTextField id_Distrito=new JTextField(10);
public JComboBox Distrito=new JComboBox();
public JTextArea Direccion=new JTextArea();
public JScrollPane sc_dir=new JScrollPane(Direccion);
public JButton bot_nuevo=new JButton(nuevo);
public JButton bot_guardar=new JButton(guardar);
public JButton bot_cancelar=new JButton(cancelar);
public Lamina_Form_Proveedor(){
Direccion.setLineWrap(true);
Mostrar_Distrito();
setLayout(new Proveedor_EnColumnas1());
L_Titulo.setForeground(new Color(0,230,64));
L_Titulo.setFont(new Font("Jokerman",1,20));
L_Nom_Proveedor.setForeground(Color.WHITE);
L_Nom_Proveedor.setFont(new Font("Tahoma",1,15));
L_Direccion.setForeground(Color.WHITE);
L_Direccion.setFont(new Font("Tahoma",1,15));
L_Celular.setForeground(Color.WHITE);
L_Celular.setFont(new Font("Tahoma",1,15));
L_Distrito.setForeground(Color.WHITE);
L_Distrito.setFont(new Font("Tahoma",1,15));
Nom_Proveedor.setBackground(new Color(103,128,159));
Nom_Proveedor.setBorder(BorderFactory.createMatteBorder(1,1,1,1,new Color(103,128,159)));
Nom_Proveedor.setForeground(Color.WHITE);
Nom_Proveedor.setFont(new Font("Tahoma",1,15));
Celular.setBackground(new Color(103,128,159));
Celular.setBorder(BorderFactory.createMatteBorder(1,1,1,1,new Color(103,128,159)));
Celular.setForeground(Color.WHITE);
Celular.setFont(new Font("Tahoma",1,15));
Distrito.setBackground(new Color(103,128,159));
Distrito.setBorder(BorderFactory.createMatteBorder(1,1,1,1,new Color(103,128,159)));
Distrito.setForeground(Color.WHITE);
Distrito.setFont(new Font("Tahoma",1,15));
Direccion.setBackground(new Color(103,128,159));
Direccion.setBorder(BorderFactory.createMatteBorder(1,1,1,1,new Color(103,128,159)));
Direccion.setForeground(Color.WHITE);
Direccion.setFont(new Font("Tahoma",1,15));
bot_nuevo.setBackground(new Color(0,230,64));
bot_nuevo.setForeground(Color.WHITE);
bot_nuevo.setFont(new Font("Tahoma",1,12));
bot_guardar.setBackground(new Color(3,201,169));
bot_guardar.setForeground(Color.WHITE);
bot_guardar.setFont(new Font("Tahoma",1,12));
bot_cancelar.setBackground(new Color(242,38,19));
bot_cancelar.setForeground(Color.WHITE);
bot_cancelar.setFont(new Font("Tahoma",1,12));
add(L_Titulo);
add(id_Proveedor);
add(L_Nom_Proveedor);
add(Nom_Proveedor);
add(L_Direccion);
add(sc_dir);
add(L_Celular);
add(Celular);
add(L_Distrito);
add(Distrito);
add(bot_nuevo);
add(bot_guardar);
add(bot_cancelar);
add(id_Distrito);
Distrito.addActionListener(new Evento_Combo());
}
public void Mostrar_Distrito(){
try{
Metodo_form_trabajador metodo=new Metodo_form_trabajador();
Distrito=metodo.Combo_Distrito();
}catch(Exception e){
JOptionPane.showMessageDialog(null,e);
}
}
private class Evento_Combo implements ActionListener{
public void actionPerformed(ActionEvent e) {
if(e.getSource()==Distrito){
Metodo_form_trabajador metod=new Metodo_form_trabajador();
id_Distrito.setText(String.valueOf(metod.Id_Distrito((String)Distrito.getSelectedItem())));
}
}
}
private class Accion_Button extends AbstractAction{
public Accion_Button(String nombre,Icon icono){
putValue(Action.NAME,nombre);
putValue(Action.SMALL_ICON,icono);
putValue(Action.SHORT_DESCRIPTION,"Haga click para " + nombre);
}
public void actionPerformed(ActionEvent e) {
if(e.getSource()==bot_nuevo){
Habilitar();
bot_guardar.setText("Guardar");
accion="Guardar";
}
if(e.getSource()==bot_guardar){
Datos_Proveedor dts=new Datos_Proveedor();
Metodo_form_Proveedor2 metod=new Metodo_form_Proveedor2();
dts.Set_Nom_Proveedor(Nom_Proveedor.getText());
dts.Set_Direccion(Direccion.getText());
dts.Set_Cel(Celular.getText());
dts.Set_Id_Distrito((Integer.parseInt(id_Distrito.getText())));
if(accion.equalsIgnoreCase("Guardar")){
if(metod.Insertar(dts)){
JOptionPane.showMessageDialog(null,"El proveedor fue registrado correctamente");
lamina2.Mostrar("");
Deshabilitar();
}
}else{
if(accion.equalsIgnoreCase("Editar")){
dts.Set_Id_Proveedor(Integer.parseInt(id_Proveedor.getText()));
lamina2.Mostrar("");
if(metod.Editar(dts)){
JOptionPane.showMessageDialog(null,"El proveedor fue editado correctamente");
lamina2.Mostrar("");
Deshabilitar();
}
}
}
}
}
}
public void Habilitar(){
id_Distrito.setVisible(false);
id_Proveedor.setVisible(false);
Nom_Proveedor.setEnabled(true);
Direccion.setEnabled(true);
Celular.setEnabled(true);
Distrito.setEnabled(true);
bot_guardar.setEnabled(true);
bot_cancelar.setEnabled(true);
id_Proveedor.setText("");
Nom_Proveedor.setText("");
Direccion.setText("");
Celular.setText("");
id_Distrito.setText("");
}
public void Deshabilitar(){
id_Distrito.setVisible(false);
id_Proveedor.setVisible(false);
Nom_Proveedor.setEnabled(false);
Direccion.setEnabled(false);
Celular.setEnabled(false);
Distrito.setEnabled(false);
bot_guardar.setEnabled(false);
bot_cancelar.setEnabled(false);
id_Proveedor.setText("");
Nom_Proveedor.setText("");
Direccion.setText("");
Celular.setText("");
id_Distrito.setText("");
}
}
//SEGUNDA LAMINA PARA MOSTRAR LA TABLA DE CLIENTES
class Lamina2_Form_Proveedor extends JPanel{
public JTable tabla;
public DefaultTableModel modelo;
public ImageIcon imagen=new ImageIcon("src/Files/bola1.png");
public Accion_Button2 buscar=new Accion_Button2("Buscar",new ImageIcon("src/Files/buscar.png"));
public Accion_Button2 eliminar=new Accion_Button2("Eliminar",new ImageIcon("src/Files/eliminar.png"));
public JLabel L_Titulo2=new JLabel ("LISTADO DE PROVEEDORES");
public JLabel L_Buscar=new JLabel("Buscar: ");
public JTextField Proveedor=new JTextField(10);
public JButton bot_buscar=new JButton(buscar);
public JButton bot_eliminar=new JButton(eliminar);
public Lamina2_Form_Proveedor(){
setLayout(new Proveedor_EnColumnas2());
L_Titulo2.setForeground(new Color(0,230,64));
L_Titulo2.setFont(new Font("Jokerman",1,20));
L_Buscar.setForeground(Color.WHITE);
L_Buscar.setFont(new Font("Tahoma",1,15));
Proveedor.setBackground(new Color(103,128,159));
Proveedor.setBorder(BorderFactory.createMatteBorder(1,1,1,1,new Color(103,128,159)));
Proveedor.setForeground(Color.WHITE);
Proveedor.setFont(new Font("Tahoma",1,15));
bot_buscar.setBackground(new Color(0,230,64));
bot_buscar.setForeground(Color.WHITE);
bot_buscar.setFont(new Font("Tahoma",1,12));
bot_eliminar.setBackground(new Color(3,201,169));
bot_eliminar.setForeground(Color.WHITE);
bot_eliminar.setFont(new Font("Tahoma",1,12));
add(L_Titulo2);
add(L_Buscar);
add(Proveedor);
add(bot_buscar);
add(bot_eliminar);
setTable();
}
public void setTable(){
modelo=new DefaultTableModel();
tabla=new JTable();
JScrollPane scroll_tabla=new JScrollPane(tabla);
scroll_tabla.setPreferredSize(new Dimension(400,450));
tabla.setModel(modelo);
add(scroll_tabla);
tabla.addMouseListener(new Evento_click());
}
public void Ocultar_Columna(){
tabla.getColumnModel().getColumn(0).setMaxWidth(0);
tabla.getColumnModel().getColumn(0).setMinWidth(0);
tabla.getColumnModel().getColumn(0).setPreferredWidth(0);
}
public void Mostrar (String buscar){
try{
DefaultTableModel modelo;
Metodo_form_Proveedor2 metodo=new Metodo_form_Proveedor2();
modelo=metodo.mostrar(buscar);
tabla.setModel(modelo);
tabla.setDefaultRenderer(Object.class,new MiRender());
tabla.getTableHeader().setPreferredSize(new Dimension(0,80));
tabla.getTableHeader().setBackground(Color.WHITE);
tabla.getTableHeader().setFont(new Font("Tahoma",1,12));
Ocultar_Columna();
}catch(Exception e){
JOptionPane.showMessageDialog(null,e);
}
}
private class Evento_click implements MouseListener{
public Evento_click(){
}
public void mouseClicked(MouseEvent e) {
lamina.bot_guardar.setText("Editar");
lamina.Habilitar();
lamina.accion="Editar";
int fila=tabla.rowAtPoint(e.getPoint());
lamina.id_Proveedor.setText(tabla.getValueAt(fila, 0).toString());
lamina.Nom_Proveedor.setText(tabla.getValueAt(fila,1).toString());
lamina.Direccion.setText(tabla.getValueAt(fila, 2).toString());
lamina.Celular.setText(tabla.getValueAt(fila, 3).toString());
lamina.Distrito.setSelectedItem(tabla.getValueAt(fila, 4).toString());
}
public void mouseEntered(MouseEvent arg0) {
// TODO Auto-generated method stub
}
public void mouseExited(MouseEvent arg0) {
// TODO Auto-generated method stub
}
public void mousePressed(MouseEvent arg0) {
// TODO Auto-generated method stub
}
public void mouseReleased(MouseEvent arg0) {
// TODO Auto-generated method stub
}
}
private class Accion_Button2 extends AbstractAction{
public Accion_Button2(String nombre,Icon icono){
putValue(Action.NAME,nombre);
putValue(Action.SMALL_ICON,icono);
putValue(Action.SHORT_DESCRIPTION,"Haz click para " + nombre);
}
public void actionPerformed(ActionEvent e) {
if(e.getSource()==bot_eliminar){
if(!lamina.id_Proveedor.getText().equalsIgnoreCase("")){
int confirmacion=JOptionPane.showConfirmDialog(null,"ยฟEstas seguro que deseas eliminar este Proveedor?","Confirmacion",2);
if(confirmacion==0){
Metodo_form_Proveedor2 metod=new Metodo_form_Proveedor2();
Datos_Proveedor dts=new Datos_Proveedor();
dts.Set_Id_Proveedor(Integer.parseInt(lamina.id_Proveedor.getText()));
if(metod.Eliminar(dts)){
JOptionPane.showMessageDialog(null, "El Proveedor fue eliminado correctamente");
Mostrar("");
lamina.Deshabilitar();
}
}
}
}
if(e.getSource()==bot_buscar){
Mostrar(Proveedor.getText());
}
}
}
}
}
class Proveedor_EnColumnas1 implements LayoutManager{
private int x;
public void addLayoutComponent(String arg0, Component arg1) {
// TODO Auto-generated method stub
}
public void layoutContainer(Container miContenedor) {
int n=miContenedor.getComponentCount();
x=50;
for(int i=0;i<n;i++){
Component c=miContenedor.getComponent(i);
if(i%2==0){
x=50;
}
switch (i){
case 0:
c.setBounds(10,10,300 ,30);
break;
case 1:
c.setBounds(x,30,150 ,20);
break;
case 2:
c.setBounds(x,110,150 ,20);
break;
case 3:
c.setBounds(x,110,150 ,20);
break;
case 4:
c.setBounds(x,140,150 ,20);
break;
case 5:
c.setBounds(x,140,250 ,70);
break;
case 6:
c.setBounds(x,230,150 ,20);
break;
case 7:
c.setBounds(x,230,150 ,20);
break;
case 8:
c.setBounds(x,260,150 ,20);
break;
case 9:
c.setBounds(x,260,200 ,20);
break;
case 10:
c.setBounds(x,380,120 ,30);
break;
case 11:
c.setBounds(230,380,120,30);
break;
case 12:
c.setBounds(400,380,120,30);
break;
case 13:
c.setBounds(470,260,20 ,20);
break;
}
x+=200;
}
}
public Dimension minimumLayoutSize(Container arg0) {
return null;
}
public Dimension preferredLayoutSize(Container arg0) {
return null;
}
public void removeLayoutComponent(Component arg0) {
}
}
class Proveedor_EnColumnas2 implements LayoutManager{
public void addLayoutComponent(String arg0, Component arg1) {
// TODO Auto-generated method stub
}
public void layoutContainer(Container miContenedor) {
int n=miContenedor.getComponentCount();
for(int i=0;i<n;i++){
Component c=miContenedor.getComponent(i);
switch (i){
case 0:
c.setBounds(10,10,300,30);
break;
case 1:
c.setBounds(20,60,90,20);
break;
case 2:
c.setBounds(80,60,150,20);
break;
case 3:
c.setBounds(240,55,120,30);
break;
case 4:
c.setBounds(370,55,120,30);
break;
case 5:
c.setBounds(10, 120, 530, 350);
break;
}
}
}
public Dimension minimumLayoutSize(Container arg0) {
// TODO Auto-generated method stub
return null;
}
public Dimension preferredLayoutSize(Container arg0) {
// TODO Auto-generated method stub
return null;
}
public void removeLayoutComponent(Component arg0) {
// TODO Auto-generated method stub
}
}
| [
"jesusalvan2010@gmail.com"
] | jesusalvan2010@gmail.com |
49a062a72491b01440e52d1b78c015dc13c4bc06 | bd62576f85821867a74d3005d962f57dbf08ae67 | /src/com/zettelnet/earley/token/Tokenizer.java | fefb1421c810363848b3c35029d79e41d45bedc5 | [] | no_license | Zettelkasten/earley | 5eba3de8e943bfd153a22c359aad795863be1f03 | 1a84eefbb0afc67b623b95069ef6d45d55b3ca53 | refs/heads/master | 2022-09-29T12:39:19.383776 | 2020-06-06T13:01:46 | 2020-06-06T13:01:46 | 211,091,523 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 135 | java | package com.zettelnet.earley.token;
import java.util.List;
public interface Tokenizer<T> {
List<T> tokenize(String raw);
}
| [
"Zettelkasten@localhost"
] | Zettelkasten@localhost |
5ef496a8dcc799513ee4f60cd81bec0fd93759b1 | 683734e4035f2eb26dd8cf4b84e2acfa1f1b96de | /src/systemstesting/QASparqlTransformQaldFiles.java | 396dab041e3635d75d89680c129bcf032b8eb537 | [
"Apache-2.0"
] | permissive | MariaPapadopoulou/CBench | 99f0cdc3776e21951ba61544eea2a11020a7326b | e6211055e54180a6f3196f66e73424e92014a30b | refs/heads/master | 2023-04-15T02:25:40.931962 | 2021-05-04T01:39:47 | 2021-05-04T01:39:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,891 | java | package systemstesting;
import DataSet.Benchmark;
import DataSet.DataSetPreprocessing;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import org.apache.jena.query.Query;
import qa.dataStructures.Question;
public class QASparqlTransformQaldFiles
{
static int benchmark = Benchmark.QALD_7;
static ArrayList<Query> qs = DataSetPreprocessing.getQueriesWithoutDuplicates(benchmark);
static ArrayList<Question> questions = DataSetPreprocessing.questions;
private static FileWriter file;
@SuppressWarnings("unchecked")
public static void main(String[] args) {
// JSON object. Key value pairs are unordered. JSONObject supports java.util.Map interface.
JSONObject root = new JSONObject();
JSONObject datasetId = new JSONObject();
datasetId.put("id", "Qald_"+ benchmark);
JSONArray quess = new JSONArray();
int counter = 0;
for (Question q : questions) {
JSONObject qObj = new JSONObject();
qObj.put("id", counter++ +"");
JSONArray qStringObjs = new JSONArray();
JSONObject qStringObj = new JSONObject();
qStringObj.put("language", "en");
qStringObj.put("string", q.getQuestionString());
qStringObj.put("keywords", q.getKeywords()==null?"":q.getKeywords());
qStringObjs.add(qStringObj);
JSONObject queryObj = new JSONObject();
queryObj.put("sparql", q.getQuestionQuery());
JSONArray answersObjs = new JSONArray();
// for (String a : q.getAnswers()) {
// answersObjs.add(a)
// }
qObj.put("question", qStringObjs);
qObj.put("query", queryObj);
qObj.put("answers", answersObjs);
quess.add(qObj);
}
root.put("dataset", datasetId);
root.put("questions", quess);
try {
// Constructs a FileWriter given a file name, using the platform's default charset
file = new FileWriter("Qald_"+benchmark+".json");
file.write(root.toJSONString()
.replaceAll("\\n", " ").replaceAll("\\r", " ").replace("\\/", "/"));
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
file.flush();
file.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
static public void CrunchifyLog(String str) {
System.out.println("str");
}
}
| [
"noreply@github.com"
] | noreply@github.com |
a9e915b496311e6d712563c7acccdc3d273a8d97 | c5488473c8114647c12b835cd7b36e1dfb4c95a9 | /Mobile App/Code/sources/android/support/p000v4/p002os/IResultReceiver.java | c546ba7ab2313513c45b6d871cdd075af81bb750 | [
"MIT"
] | permissive | shivi98g/EpilNet-EpilepsyPredictor | 5cf86835473112f98c130bb066edba4cf8fa3f20 | 15a98fb9ac7ee535005fb2aebb36548f28c7f6d1 | refs/heads/main | 2023-08-04T09:43:24.941854 | 2021-09-24T12:25:42 | 2021-09-24T12:25:42 | 389,867,899 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,125 | java | package android.support.p000v4.p002os;
import android.os.Binder;
import android.os.Bundle;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
/* renamed from: android.support.v4.os.IResultReceiver */
public interface IResultReceiver extends IInterface {
void send(int i, Bundle bundle) throws RemoteException;
/* renamed from: android.support.v4.os.IResultReceiver$Stub */
public static abstract class Stub extends Binder implements IResultReceiver {
private static final String DESCRIPTOR = "android.support.v4.os.IResultReceiver";
static final int TRANSACTION_send = 1;
public Stub() {
attachInterface(this, DESCRIPTOR);
}
public static IResultReceiver asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (iin == null || !(iin instanceof IResultReceiver)) {
return new Proxy(obj);
}
return (IResultReceiver) iin;
}
public IBinder asBinder() {
return this;
}
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
Bundle _arg1;
if (code == 1) {
data.enforceInterface(DESCRIPTOR);
int _arg0 = data.readInt();
if (data.readInt() != 0) {
_arg1 = (Bundle) Bundle.CREATOR.createFromParcel(data);
} else {
_arg1 = null;
}
send(_arg0, _arg1);
return true;
} else if (code != 1598968902) {
return super.onTransact(code, data, reply, flags);
} else {
reply.writeString(DESCRIPTOR);
return true;
}
}
/* renamed from: android.support.v4.os.IResultReceiver$Stub$Proxy */
private static class Proxy implements IResultReceiver {
private IBinder mRemote;
Proxy(IBinder remote) {
this.mRemote = remote;
}
public IBinder asBinder() {
return this.mRemote;
}
public String getInterfaceDescriptor() {
return Stub.DESCRIPTOR;
}
public void send(int resultCode, Bundle resultData) throws RemoteException {
Parcel _data = Parcel.obtain();
try {
_data.writeInterfaceToken(Stub.DESCRIPTOR);
_data.writeInt(resultCode);
if (resultData != null) {
_data.writeInt(1);
resultData.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
this.mRemote.transact(1, _data, (Parcel) null, 1);
} finally {
_data.recycle();
}
}
}
}
}
| [
"31238277+shivi98g@users.noreply.github.com"
] | 31238277+shivi98g@users.noreply.github.com |
213d01e73ac9c14986c88b5685eec7beb4963785 | 75f821238e6b2570986c1809925bdb638b7a9264 | /app/src/main/java/com/tonfun/codecsnetty/bll/protocol/commons/transform/parameter/ParamBSD.java | 365da7bfbbf19987629316c1ec14b77e5977bfaa | [] | no_license | zgy520/Android808 | 16d9dcf75de1e5c097629e9c1fa1fb94d640a827 | 4643bca92228366eadbbde8a3566da3319ea4462 | refs/heads/master | 2023-04-09T20:59:56.352962 | 2021-04-10T03:40:14 | 2021-04-10T03:40:14 | 356,259,966 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,357 | java | package com.tonfun.codecsnetty.bll.protocol.commons.transform.parameter;
import io.netty.buffer.ByteBuf;
/**
* ็ฒๅบ็ๆต็ณป็ปๅๆฐ
* @author yezhihao
* @home https://gitee.com/yezhihao/jt808-server
*/
public class ParamBSD {
public static final int id = 0xF367;
public static int id() {
return id;
}
// @Schema(description = "ๅๆนๆฅ่ฟๆฅ่ญฆๆถ้ด้ๅผ")
private byte p0;
// @Schema(description = "ไพงๅๆนๆฅ่ฟๆฅ่ญฆๆถ้ด้ๅผ")
private byte p1;
public ParamBSD() {
}
public byte getP0() {
return p0;
}
public void setP0(byte p0) {
this.p0 = p0;
}
public byte getP1() {
return p1;
}
public void setP1(byte p1) {
this.p1 = p1;
}
public static class S implements io.github.yezhihao.protostar.Schema<ParamBSD> {
public static final S INSTANCE = new S();
private S() {
}
@Override
public ParamBSD readFrom(ByteBuf input) {
ParamBSD message = new ParamBSD();
message.p0 = input.readByte();
message.p1 = input.readByte();
return message;
}
@Override
public void writeTo(ByteBuf output, ParamBSD message) {
output.writeByte(message.p0);
output.writeByte(message.p1);
}
}
}
| [
"a442391947@gmail.com"
] | a442391947@gmail.com |
289f4b432ee6a954adce4ec305200dc1183e62a4 | cb762d4b0f0ea986d339759ba23327a5b6b67f64 | /src/service/com/joymain/jecs/util/mobil/MobilWebUtilImpl.java | eb054a3d379c4e8a0216942cd474251d22d15740 | [
"Apache-2.0"
] | permissive | lshowbiz/agnt_ht | c7d68c72a1d5fa7cd0e424eabb9159d3552fe9dc | fd549de35cb12a2e3db1cd9750caf9ce6e93e057 | refs/heads/master | 2020-08-04T14:24:26.570794 | 2019-10-02T03:04:13 | 2019-10-02T03:04:13 | 212,160,437 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 23,329 | java | package com.joymain.jecs.util.mobil;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URLDecoder;
import java.security.PublicKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import net.sf.json.JSONObject;
import sun.misc.BASE64Decoder;
import com.joymain.jecs.fi.model.Jfi99billLog;
import com.joymain.jecs.fi.service.Jfi99billLogManager;
import com.joymain.jecs.po.model.JpoMemberOrder;
import com.joymain.jecs.po.service.JpoMemberOrderManager;
import com.joymain.jecs.util.bill99.Bill99Constants;
import com.joymain.jecs.util.bill99.MD5Util;
/**
* ๆๆบๅฟซ้ฑๆฏไป้ช็ญพๅ
ฅ่ดฆๅค็ๅฎ็ฐ็ฑป
* @author Administrator
*
*/
public class MobilWebUtilImpl implements MobilWebUtil {
private Jfi99billLogManager jfi99billLogManager = null;
private JpoMemberOrderManager jpoMemberOrderManager = null;
public void setJfi99billLogManager(Jfi99billLogManager jfi99billLogManager) {
this.jfi99billLogManager = jfi99billLogManager;
}
public void setJpoMemberOrderManager(JpoMemberOrderManager jpoMemberOrderManager) {
this.jpoMemberOrderManager = jpoMemberOrderManager;
}
final String pubKeyName = "key/app/99bill.cert.rsa.20340630.cer";
/**
* ้ช็ญพ (PKI)
* @param request
* @return
*/
public boolean checkJfi99billLog(HttpServletRequest request){
boolean flag=false;
//ไบบๆฐๅธ็ฝๅ
ณ่ดฆๅท๏ผ่ฏฅ่ดฆๅทไธบ11ไฝไบบๆฐๅธ็ฝๅ
ณๅๆท็ผๅท+01,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String merchantAcctId = request.getParameter("merchantAcctId");
//็ฝๅ
ณ็ๆฌ๏ผๅบๅฎๅผ๏ผv2.0,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String version = request.getParameter("version");
//่ฏญ่จ็ง็ฑป๏ผ1ไปฃ่กจไธญๆๆพ็คบ๏ผ2ไปฃ่กจ่ฑๆๆพ็คบใ้ป่ฎคไธบ1,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String language = request.getParameter("language");
//็ญพๅ็ฑปๅ,่ฏฅๅผไธบ4๏ผไปฃ่กจPKIๅ ๅฏๆนๅผ,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String signType = request.getParameter("signType");
//ๆฏไปๆนๅผ๏ผไธ่ฌไธบ00๏ผไปฃ่กจๆๆ็ๆฏไปๆนๅผใๅฆๆๆฏ้ถ่ก็ด่ฟๅๆท๏ผ่ฏฅๅผไธบ10,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String payType = request.getParameter("payType");
//้ถ่กไปฃ็ ๏ผๅฆๆpayTypeไธบ00๏ผ่ฏฅๅผไธบ็ฉบ๏ผๅฆๆpayTypeไธบ10,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String bankId = request.getParameter("bankId");
//ๅๆท่ฎขๅๅท๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String orderId = request.getParameter("orderId");
//่ฎขๅๆไบคๆถ้ด๏ผๆ ผๅผ๏ผyyyyMMddHHmmss๏ผๅฆ๏ผ20071117020101,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String orderTime = request.getParameter("orderTime");
//่ฎขๅ้้ข๏ผ้้ขไปฅโๅโไธบๅไฝ๏ผๅๆทๆต่ฏไปฅ1ๅๆต่ฏๅณๅฏ๏ผๅๅฟไปฅๅคง้้ขๆต่ฏ,่ฏฅๅผไธๆฏไปๆถ็ธๅใ
String orderAmount = request.getParameter("orderAmount");
// ๅฟซ้ฑไบคๆๅท๏ผๅๆทๆฏไธ็ฌไบคๆ้ฝไผๅจๅฟซ้ฑ็ๆไธไธชไบคๆๅทใ
String dealId = request.getParameter("dealId");
//้ถ่กไบคๆๅท ๏ผๅฟซ้ฑไบคๆๅจ้ถ่กๆฏไปๆถๅฏนๅบ็ไบคๆๅท๏ผๅฆๆไธๆฏ้่ฟ้ถ่กๅกๆฏไป๏ผๅไธบ็ฉบ
String bankDealId = request.getParameter("bankDealId");
//ๅฟซ้ฑไบคๆๆถ้ด๏ผๅฟซ้ฑๅฏนไบคๆ่ฟ่กๅค็็ๆถ้ด,ๆ ผๅผ๏ผyyyyMMddHHmmss๏ผๅฆ๏ผ20071117020101
String dealTime = request.getParameter("dealTime");
//ๅๆทๅฎ้
ๆฏไป้้ข ไปฅๅไธบๅไฝใๆฏๆน10ๅ
๏ผๆไบคๆถ้้ขๅบไธบ1000ใ่ฏฅ้้ขไปฃ่กจๅๆทๅฟซ้ฑ่ดฆๆทๆ็ปๆถๅฐ็้้ขใ
String payAmount = request.getParameter("payAmount");
//่ดน็จ๏ผๅฟซ้ฑๆถๅๅๆท็ๆ็ปญ่ดน๏ผๅไฝไธบๅใ
String fee = request.getParameter("fee");
//ๆฉๅฑๅญๆฎต1๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String ext1 = request.getParameter("ext1");
//ๆฉๅฑๅญๆฎต2๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String ext2 = request.getParameter("ext2");
//ๅค็็ปๆ๏ผ 10ๆฏไปๆๅ๏ผ11 ๆฏไปๅคฑ่ดฅ๏ผ00่ฎขๅ็ณ่ฏทๆๅ๏ผ01 ่ฎขๅ็ณ่ฏทๅคฑ่ดฅ
String payResult = request.getParameter("payResult");
String key = request.getParameter("key");
if(key == null)
key = "7Y43ME4H3Y5D3RG9";
//้่ฏฏไปฃ็ ๏ผ่ฏทๅ็
งใไบบๆฐๅธ็ฝๅ
ณๆฅๅฃๆๆกฃใๆๅ้จๅ็่ฏฆ็ป่งฃ้ใ
String errCode = request.getParameter("errCode");
//็ญพๅๅญ็ฌฆไธฒ
String signMsg = request.getParameter("signMsg");
String bindCard = request.getParameter("bindCard");
String bindMobile = request.getParameter("bindMobile");
String merchantSignMsgVal = "";
merchantSignMsgVal = appendParam(merchantSignMsgVal,"merchantAcctId", merchantAcctId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "version",version);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "language",language);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "signType",signType);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payType",payType);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bankId",bankId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderId",orderId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderTime",orderTime);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderAmount",orderAmount);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bindCard",bindCard);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bindMobile",bindMobile);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "dealId",dealId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bankDealId",bankDealId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "dealTime",dealTime);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payAmount",payAmount);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "fee", fee);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "ext1", ext1);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "ext2", ext2);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payResult",payResult);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "errCode",errCode);
try {
//PKIUtil pkiUtil=new PKIUtil();
boolean verifyData = verifyData(merchantSignMsgVal, signMsg, pubKeyName);
flag = verifyData;
} catch (Exception e) {
e.printStackTrace();
}
return flag;
}
/**
* ้ช็ญพ
* @param request
* @return
*/
public boolean checkMD5Jfi99billLog(HttpServletRequest request){
boolean flag=false;
//ไบบๆฐๅธ็ฝๅ
ณ่ดฆๅท๏ผ่ฏฅ่ดฆๅทไธบ11ไฝไบบๆฐๅธ็ฝๅ
ณๅๆท็ผๅท+01,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String merchantAcctId = request.getParameter("merchantAcctId");
//็ฝๅ
ณ็ๆฌ๏ผๅบๅฎๅผ๏ผv2.0,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String version = request.getParameter("version");
//่ฏญ่จ็ง็ฑป๏ผ1ไปฃ่กจไธญๆๆพ็คบ๏ผ2ไปฃ่กจ่ฑๆๆพ็คบใ้ป่ฎคไธบ1,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String language = request.getParameter("language");
//็ญพๅ็ฑปๅ,่ฏฅๅผไธบ4๏ผไปฃ่กจPKIๅ ๅฏๆนๅผ,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String signType = request.getParameter("signType");
//ๆฏไปๆนๅผ๏ผไธ่ฌไธบ00๏ผไปฃ่กจๆๆ็ๆฏไปๆนๅผใๅฆๆๆฏ้ถ่ก็ด่ฟๅๆท๏ผ่ฏฅๅผไธบ10,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String payType = request.getParameter("payType");
//้ถ่กไปฃ็ ๏ผๅฆๆpayTypeไธบ00๏ผ่ฏฅๅผไธบ็ฉบ๏ผๅฆๆpayTypeไธบ10,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String bankId = request.getParameter("bankId");
//ๅๆท่ฎขๅๅท๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String orderId = request.getParameter("orderId");
//่ฎขๅๆไบคๆถ้ด๏ผๆ ผๅผ๏ผyyyyMMddHHmmss๏ผๅฆ๏ผ20071117020101,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String orderTime = request.getParameter("orderTime");
//่ฎขๅ้้ข๏ผ้้ขไปฅโๅโไธบๅไฝ๏ผๅๆทๆต่ฏไปฅ1ๅๆต่ฏๅณๅฏ๏ผๅๅฟไปฅๅคง้้ขๆต่ฏ,่ฏฅๅผไธๆฏไปๆถ็ธๅใ
String orderAmount = request.getParameter("orderAmount");
// ๅฟซ้ฑไบคๆๅท๏ผๅๆทๆฏไธ็ฌไบคๆ้ฝไผๅจๅฟซ้ฑ็ๆไธไธชไบคๆๅทใ
String dealId = request.getParameter("dealId");
//้ถ่กไบคๆๅท ๏ผๅฟซ้ฑไบคๆๅจ้ถ่กๆฏไปๆถๅฏนๅบ็ไบคๆๅท๏ผๅฆๆไธๆฏ้่ฟ้ถ่กๅกๆฏไป๏ผๅไธบ็ฉบ
String bankDealId = request.getParameter("bankDealId");
//ๅฟซ้ฑไบคๆๆถ้ด๏ผๅฟซ้ฑๅฏนไบคๆ่ฟ่กๅค็็ๆถ้ด,ๆ ผๅผ๏ผyyyyMMddHHmmss๏ผๅฆ๏ผ20071117020101
String dealTime = request.getParameter("dealTime");
//ๅๆทๅฎ้
ๆฏไป้้ข ไปฅๅไธบๅไฝใๆฏๆน10ๅ
๏ผๆไบคๆถ้้ขๅบไธบ1000ใ่ฏฅ้้ขไปฃ่กจๅๆทๅฟซ้ฑ่ดฆๆทๆ็ปๆถๅฐ็้้ขใ
String payAmount = request.getParameter("payAmount");
//่ดน็จ๏ผๅฟซ้ฑๆถๅๅๆท็ๆ็ปญ่ดน๏ผๅไฝไธบๅใ
String fee = request.getParameter("fee");
//ๆฉๅฑๅญๆฎต1๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String ext1 = request.getParameter("ext1");
//ๆฉๅฑๅญๆฎต2๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String ext2 = request.getParameter("ext2");
//ๅค็็ปๆ๏ผ 10ๆฏไปๆๅ๏ผ11 ๆฏไปๅคฑ่ดฅ๏ผ00่ฎขๅ็ณ่ฏทๆๅ๏ผ01 ่ฎขๅ็ณ่ฏทๅคฑ่ดฅ
String payResult = request.getParameter("payResult");
String key = request.getParameter("key");
if(key == null)
key = "7Y43ME4H3Y5D3RG9";
//้่ฏฏไปฃ็ ๏ผ่ฏทๅ็
งใไบบๆฐๅธ็ฝๅ
ณๆฅๅฃๆๆกฃใๆๅ้จๅ็่ฏฆ็ป่งฃ้ใ
String errCode = request.getParameter("errCode");
//็ญพๅๅญ็ฌฆไธฒ
String signMsg = request.getParameter("signMsg");
String bindCard = request.getParameter("bindCard");
String bindMobile = request.getParameter("bindMobile");
String merchantSignMsgVal = "";
merchantSignMsgVal = appendParam(merchantSignMsgVal,"merchantAcctId", merchantAcctId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "version",version);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "language",language);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "signType",signType);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payType",payType);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bankId",bankId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderId",orderId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderTime",orderTime);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderAmount",orderAmount);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bindCard",bindCard);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bindMobile",bindMobile);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "dealId",dealId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bankDealId",bankDealId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "dealTime",dealTime);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payAmount",payAmount);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "fee", fee);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "ext1", ext1);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "ext2", ext2);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payResult",payResult);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "errCode",errCode);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "key",key);
//Pkipair pki = new Pkipair();
//System.out.println(signMsgVal);
String merchantSignMsg = "";
try {
merchantSignMsg = MD5Util.md5Hex(merchantSignMsgVal.getBytes("UTF-8")).toUpperCase();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(merchantSignMsg.equals(signMsg)){
flag = true;
}
return flag;
}
public String appendParam(String returns, String paramId, String paramValue) {
if (!returns.equals("")) {
if (paramValue!=null && !("").equals(paramValue)) {
returns += "&" + paramId + "=" + paramValue;
}
} else {
if (paramValue!=null && !("").equals(paramValue)) {
returns = paramId + "=" + paramValue;
}
}
return returns;
}
/**
* ็ๆๅๅงJfi99billLog
*/
public Jfi99billLog setJfi99billLog(HttpServletRequest request){
//ไบบๆฐๅธ็ฝๅ
ณ่ดฆๅท๏ผ่ฏฅ่ดฆๅทไธบ11ไฝไบบๆฐๅธ็ฝๅ
ณๅๆท็ผๅท+01,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String merchantAcctId = request.getParameter("merchantAcctId");
//็ฝๅ
ณ็ๆฌ๏ผๅบๅฎๅผ๏ผv2.0,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String version = request.getParameter("version");
//่ฏญ่จ็ง็ฑป๏ผ1ไปฃ่กจไธญๆๆพ็คบ๏ผ2ไปฃ่กจ่ฑๆๆพ็คบใ้ป่ฎคไธบ1,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String language = request.getParameter("language");
//็ญพๅ็ฑปๅ,่ฏฅๅผไธบ4๏ผไปฃ่กจPKIๅ ๅฏๆนๅผ,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String signType = request.getParameter("signType");
//ๆฏไปๆนๅผ๏ผไธ่ฌไธบ00๏ผไปฃ่กจๆๆ็ๆฏไปๆนๅผใๅฆๆๆฏ้ถ่ก็ด่ฟๅๆท๏ผ่ฏฅๅผไธบ10,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String payType = request.getParameter("payType");
//้ถ่กไปฃ็ ๏ผๅฆๆpayTypeไธบ00๏ผ่ฏฅๅผไธบ็ฉบ๏ผๅฆๆpayTypeไธบ10,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String bankId = request.getParameter("bankId");
//ๅๆท่ฎขๅๅท๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String orderId = request.getParameter("orderId");
//่ฎขๅๆไบคๆถ้ด๏ผๆ ผๅผ๏ผyyyyMMddHHmmss๏ผๅฆ๏ผ20071117020101,่ฏฅๅผไธๆไบคๆถ็ธๅใ
String orderTime = request.getParameter("orderTime");
//่ฎขๅ้้ข๏ผ้้ขไปฅโๅโไธบๅไฝ๏ผๅๆทๆต่ฏไปฅ1ๅๆต่ฏๅณๅฏ๏ผๅๅฟไปฅๅคง้้ขๆต่ฏ,่ฏฅๅผไธๆฏไปๆถ็ธๅใ
String orderAmount = request.getParameter("orderAmount");
// ๅฟซ้ฑไบคๆๅท๏ผๅๆทๆฏไธ็ฌไบคๆ้ฝไผๅจๅฟซ้ฑ็ๆไธไธชไบคๆๅทใ
String dealId = request.getParameter("dealId");
//้ถ่กไบคๆๅท ๏ผๅฟซ้ฑไบคๆๅจ้ถ่กๆฏไปๆถๅฏนๅบ็ไบคๆๅท๏ผๅฆๆไธๆฏ้่ฟ้ถ่กๅกๆฏไป๏ผๅไธบ็ฉบ
String bankDealId = request.getParameter("bankDealId");
//ๅฟซ้ฑไบคๆๆถ้ด๏ผๅฟซ้ฑๅฏนไบคๆ่ฟ่กๅค็็ๆถ้ด,ๆ ผๅผ๏ผyyyyMMddHHmmss๏ผๅฆ๏ผ20071117020101
String dealTime = request.getParameter("dealTime");
//ๅๆทๅฎ้
ๆฏไป้้ข ไปฅๅไธบๅไฝใๆฏๆน10ๅ
๏ผๆไบคๆถ้้ขๅบไธบ1000ใ่ฏฅ้้ขไปฃ่กจๅๆทๅฟซ้ฑ่ดฆๆทๆ็ปๆถๅฐ็้้ขใ
String payAmount = request.getParameter("payAmount");
//่ดน็จ๏ผๅฟซ้ฑๆถๅๅๆท็ๆ็ปญ่ดน๏ผๅไฝไธบๅใ
String fee = request.getParameter("fee");
//ๆฉๅฑๅญๆฎต1๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String ext1 = request.getParameter("ext1");
//ๆฉๅฑๅญๆฎต2๏ผ่ฏฅๅผไธๆไบคๆถ็ธๅใ
String ext2 = request.getParameter("ext2");
//ๅค็็ปๆ๏ผ 10ๆฏไปๆๅ๏ผ11 ๆฏไปๅคฑ่ดฅ๏ผ00่ฎขๅ็ณ่ฏทๆๅ๏ผ01 ่ฎขๅ็ณ่ฏทๅคฑ่ดฅ
String payResult = request.getParameter("payResult");
//้่ฏฏไปฃ็ ๏ผ่ฏทๅ็
งใไบบๆฐๅธ็ฝๅ
ณๆฅๅฃๆๆกฃใๆๅ้จๅ็่ฏฆ็ป่งฃ้ใ
String errCode = request.getParameter("errCode");
//็ญพๅๅญ็ฌฆไธฒ
String signMsg = request.getParameter("signMsg");
String bindCard = request.getParameter("bindCard");
String bindMobile = request.getParameter("bindMobile");
String merchantSignMsgVal = "";
merchantSignMsgVal = appendParam(merchantSignMsgVal,"merchantAcctId", merchantAcctId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "version",version);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "language",language);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "signType",signType);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payType",payType);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bankId",bankId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderId",orderId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderTime",orderTime);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "orderAmount",orderAmount);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bindCard",bindCard);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bindMobile",bindMobile);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "dealId",dealId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "bankDealId",bankDealId);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "dealTime",dealTime);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payAmount",payAmount);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "fee", fee);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "ext1", ext1);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "ext2", ext2);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "payResult",payResult);
merchantSignMsgVal = appendParam(merchantSignMsgVal, "errCode",errCode);
//่ฎฐๅฝๅฟซ้ฑๆฏไป่ฎฐๅฝ
Jfi99billLog jfi99billLog = new Jfi99billLog();
jfi99billLog.setInc("0");//1่ฟ็ตๅญๅญๆ 0ๆฒก่ฟ็ตๅญๅญๆ
jfi99billLog.setCompanyCode("CN");
jfi99billLog.setUrl(request.getRequestURL().toString() + "?" + request.getQueryString());//ๅฟซ้ฑ่ฟๅ็RUL
//่ทๅ่ฎขๅ็ผๅทใไผๅ็ผๅทใflag
// String externalTraceNo[] = request.getParameter("ext2").split(",");
String reserved = request.getParameter("ext2");
String jstr = reserved.substring(reserved.indexOf("[") + 1, reserved.indexOf("]"));
JSONObject json = JSONObject.fromObject(jstr);;
String flag = json.getString("payType");//externalTraceNo[1];//ๆ ่ฏ,1:่ฎขๅๆฏไป,0๏ผๅ
ๅผ
String userCode = json.getString("userCode");//externalTraceNo[0];//ไผๅ็ผๅท
jfi99billLog.setUserCode(userCode);//ไผๅ็ผๅท
jfi99billLog.setOrderId(orderId);//ไผๅ่ฎขๅๅท
//่ทๅๅฎ้
ๆฏไป้้ข
//BigDecimal amount = new BigDecimal(payAmount).multiply(new BigDecimal(100));
jfi99billLog.setPayAmount(payAmount);
if("1".equals(flag)){//่ฎขๅๅฎกๆ ธ
jfi99billLog.setOrderAmount(this.getOrderAmountByOrderId(orderId, payAmount.toString()));//ๆ นๆฎ่ฎขๅID่ทๅ่ฎขๅๆป้้ข
}
if("0".equals(flag)){//ๅ
ๅผ
jfi99billLog.setOrderAmount(payAmount);
}
jfi99billLog.setOrderTime(orderTime);
jfi99billLog.setFee(fee);//ๅฟซ้ฑไบคๆๆ็ปญ่ดน
jfi99billLog.setDealId(dealId);//่ทๅๅฟซ้ฑไบคๆๅท๏ผ่ทๅ่ฏฅไบคๆๅจๅฟซ้ฑ็ไบคๆๅท,ๆๆถ่ฏปๅๆๆๅท
//่ทๅ้ถ่กไปฃ็ ๅ่ง้ถ่กไปฃ็ ๅ่กจ๏ผๆๆถ่ฏปๅๅๅกๆบๆ
jfi99billLog.setBankId(bankId);
jfi99billLog.setBankDealId(bankDealId);
//jfi99billLog.setBankDealId(request.getParameter("RRN"));//่ทๅ้ถ่กไบคๆๅ่ๅท
jfi99billLog.setDealTime(dealTime);//่ทๅๅจๅฟซ้ฑไบคๆๆถ้ด
jfi99billLog.setMerchantAcctId(merchantAcctId);//่ทๅไบบๆฐๅธ็ฝๅ
ณ่ดฆๆทๅท,ๅฟซ้ฑๅๆทๅท
jfi99billLog.setErrCode(errCode);//่ฎพ็ฝฎ้่ฏฏ็ ๏ผ่ทๅไบคๆ่ฟๅ็
jfi99billLog.setExt2(ext2);//่ฎพ็ฝฎๆฉๅฑๅญๆฎต2,ไผๅ็ผๅทใๆ ่ฏ
jfi99billLog.setPayType("2");//่ฎพ็ฝฎๆฏไปๆนๅผ,ไปฃ่กจๆๆบๆฏไป
jfi99billLog.setBillLanguage(language);//่ฎพ็ฝฎ่ฏญ่จ็ง็ฑป,1ไปฃ่กจไธญๆๆพ็คบ๏ผ2ไปฃ่กจ่ฑๆๆพ็คบใ้ป่ฎคไธบ1,่ฏฅๅผไธๆไบคๆถ็ธๅใ
jfi99billLog.setSignType(signType);//็ญพๅ็ฑปๅ.ๅบ 1ไปฃ่กจMD5็ญพๅ ๅฝๅ็ๆฌๅบๅฎไธบ1,่ฏฅๅผไธบ4๏ผไปฃ่กจPKIๅ ๅฏๆนๅผ
jfi99billLog.setSignMsg(signMsg);//่ทๅๅ ๅฏ็ญพๅไธฒ
//ๅค็็ปๆ๏ผ 10ๆฏไปๆๅ๏ผ11 ๆฏไปๅคฑ่ดฅ๏ผ00่ฎขๅ็ณ่ฏทๆๅ๏ผ01 ่ฎขๅ็ณ่ฏทๅคฑ่ดฅ
jfi99billLog.setPayResult(payResult);
jfi99billLog.setVersion(version);
jfi99billLog.setExt1(ext1);
//jfi99billLog.setReferer("");//ๆฅๆบ้กต
jfi99billLog.setCreateTime(new Date());
return jfi99billLog;
}
/**
* ่ทๅๅฟซ้ฑ่ฟๅไฟกๆฏ๏ผ้ช็ญพ๏ผไฟๅญๅฟซ้ฑๆฏไป่ฎฐๅฝ
*/
@Override
public Jfi99billLog getJfi99billLog(HttpServletRequest request) {
int rtnMsg = 0;//้ช็ญพ็ถๆ๏ผ0่กจ็คบ่ขซ็ฏกๆน,2่กจ็คบๆฃๆฌพๅคฑ่ดฅ,2่ชๅฎไนMD5็ญพๅ่ขซ็ฏกๆน(ๅฟซ้ฑ็ญพๅ่ขซ็ฏกๆน),3ๆฏไปๆฐๆฎ้ๆฐๅ้,10่กจ็คบๆๅๆ ก้ช
/*
* ็ฌฌ1ๆญฅ๏ผ่ทๅๅฟซ้ฑๅ้็้็ฅๅๆฐ,่ฎพ็ฝฎๅฐJfi99billLogๅฏน่ฑก
*/
Jfi99billLog jfi99billLog = this.setJfi99billLog(request);
/*
* ็ฌฌ2ๆญฅ๏ผ้ช็ญพ
*/
boolean flag = this.checkJfi99billLog(request);
//้ช็ญพ้่ฟ
if (flag) {
//ๆฃๆฌพๆๅ
if("10".equals(jfi99billLog.getPayResult())){
//็ญพๅๅญ็ฌฆไธฒ้ช่ฏ็ปๆ
jfi99billLog.setVerifySignResult(String.valueOf(flag));
/**
* ็ฌฌ3ๆญฅ๏ผๆฅ่ฏขๅๅฒๆฐๆฎ๏ผๆฅ่ฏขๆฐๆฎๆฏๅฆ้ๅ
*/
if(jfi99billLogManager.getSuccessJfi99billLogsByConditions(jfi99billLog.getDealId()).size()>0){
rtnMsg = 3;//้ๅไฟกๆฏ
}else{
rtnMsg = 10;//ๆๅๆ ก้ช
}
}else{
rtnMsg = 20;//ๆๆบๆฃๆฌพๅคฑ่ดฅ
}
} else {
rtnMsg = 4;//้ช็ญพไธ้่ฟ
}
//้ช็ญพ็ถๆ: 10:ไปฃ่กจๆๅๆ ก้ช๏ผ3๏ผ้ๅไฟกๆฏ,0:่กจ็คบ่ขซ็ฏกๆน,2:ๆฃๆฌพๅคฑ่ดฅ
jfi99billLog.setReturnMsg(String.valueOf(rtnMsg));
jfi99billLog.setDataType("2");//ๆฐๆฎๆฅๆบ๏ผ2๏ผๆๆบ็งปๅจ็ป็ซฏ
/*
* ็ฌฌ4ๆญฅ๏ผไฟๅญๅฟซ้ฑ่ฟๅๆฐๆฎ
*/
this.jfi99billLogManager.saveJfi99billLog(jfi99billLog);
return jfi99billLog;
}
public boolean verifyData(String orgdata, String sign, String pubKeyNames) {
BASE64Decoder decoder = new BASE64Decoder();
boolean flag = false;
InputStream inputStream = null;
try {
if (Bill99Constants.publicKey == null) {
String file = this.getClass().getClassLoader().getResource(pubKeyNames).getPath();
file = URLDecoder.decode(file, "utf-8");
inputStream = new FileInputStream(new File(file));
CertificateFactory certificateFactory = CertificateFactory.getInstance("X509");// ๅๅงๅๅฏ้ฅ
Certificate certificate = certificateFactory.generateCertificate(inputStream);// ๅ ่ฝฝๅ
ฌ้ฅ
PublicKey publicKey = certificate.getPublicKey();// ่ทๅๅ
ฌ้ฅ
Bill99Constants.publicKey = publicKey;
byte[] signData = decoder.decodeBuffer(sign);
Signature s = Signature.getInstance("SHA1withRSA");
s.initVerify(publicKey);
s.update(orgdata.getBytes("utf-8"));
flag = s.verify(signData);// ้ช็ญพๅญ็ฌฆไธฒ
} else {
byte[] signData;
signData = decoder.decodeBuffer(sign);
Signature s = Signature.getInstance("SHA1withRSA");
s.initVerify(Bill99Constants.publicKey);
s.update(orgdata.getBytes("utf-8"));
flag = s.verify(signData);// ้ช็ญพๅญ็ฌฆไธฒ
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return flag;
}
/**
* ๆ นๆฎ่ฎขๅID่ทๅ่ฎขๅๆป้้ข,ๅฆๆๆฅๆพไธๅฐ่ฎขๅ๏ผ่ฟๅๆฏไป้้ข
* @param moId
* @param amount
* @return
*/
public String getOrderAmountByOrderId(String moId, String amount){
try{
JpoMemberOrder jpoMemberOrder = jpoMemberOrderManager.getJpoMemberOrder(moId);//ๆฅ่ฏข่ฎขๅๅฏน่ฑก
if(jpoMemberOrder!=null){
BigDecimal payAmount = jpoMemberOrder.getAmount().multiply(new BigDecimal(100));
return payAmount.toString();
}else{
return amount;
}
}catch(Exception e){
return amount;
}
}
public static void main(String[] args) {
String reserved ="[{userCode:\"CN37466666\",payType:\"1\",payFee:0.00,dataType:2,isFull:false}]";
String jstr = reserved.substring(reserved.indexOf("[") + 1, reserved.indexOf("]"));
JSONObject json = JSONObject.fromObject(jstr);;
System.out.println(json.get("userCode")+"=="+json.get("payFee"));
}
}
| [
"727736571@qq.com"
] | 727736571@qq.com |
4576ff743e1a63e0f2082d82acbe5334f4f17f91 | b5d40e84426a7a605eacd90bb85992a748c2e0fb | /src/br/discoverconcernsinkdm/tagManager/KDMAnnotation.java | dba2a9a6e444576eaf5d469d29aab1d646387871 | [] | no_license | dsanmartins/cckdm | 0e8f88ec7349193dc83c62df1e8de039c9c3b5d2 | 0cf1591415c399002987e9125831d2ad6cebbf73 | refs/heads/master | 2021-01-18T20:13:08.398844 | 2017-04-11T18:59:18 | 2017-04-11T18:59:18 | 86,944,602 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 16,178 | java | /*
* Copyright 2013 Daniel Gustavo San Martรญn Santibรกรฑez
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 br.discoverconcernsinkdm.tagManager;
import java.sql.SQLException;
import java.util.ArrayList;
import org.apache.log4j.Logger;
import org.basex.core.BaseXException;
import org.basex.core.Context;
import org.basex.core.cmd.Close;
import org.basex.core.cmd.CreateDB;
import org.basex.core.cmd.DropDB;
import org.basex.core.cmd.Export;
import org.basex.core.cmd.Open;
import org.basex.query.QueryException;
import org.basex.query.QueryProcessor;
import org.basex.query.iter.Iter;
import org.basex.query.value.item.Item;
import br.discoverconcernsinkdm.persistenceManager.Query;
public class KDMAnnotation implements Annotation {
Context context;
CreateDB createDB;
String path;
Open openDb;
Close closeDb;
DropDB dropDB;
Export export;
static Logger log = Logger.getLogger(KDMAnnotation.class);
public KDMAnnotation(String path, String file, String dbName) throws BaseXException
{
// Create a database from a local or remote XML document or XML String
context = new Context();
createDB = new CreateDB(dbName, path + file);
createDB.execute(context);
this.path = path + file;
openDb = new Open(dbName);
closeDb = new Close();
export = new Export(this.path);
dropDB = new DropDB(dbName);
}
@Override
/*
*
*/
public void createDB(String path, String file, String dbName) throws BaseXException {
// TODO Auto-generated method stub
context = new Context();
createDB = new CreateDB(dbName, path + file);
createDB.execute(context);
openDb = new Open(dbName);
}
/* (non-Javadoc)
* @see br.discoverconcernsinkdm.xquery.Annotation#openDB()
*/
@Override
public void openDB() throws BaseXException
{
openDb.execute(context);
}
/* (non-Javadoc)
* @see br.discoverconcernsinkdm.xquery.Annotation#closeDB()
*/
@Override
public void closeDB() throws BaseXException
{
closeDb.execute(context);
}
/* (non-Javadoc)
* @see br.discoverconcernsinkdm.xquery.Annotation#exportDB()
*/
@Override
public void exportDB() throws BaseXException
{
export.execute(context);
}
/* (non-Javadoc)
* @see br.discoverconcernsinkdm.xquery.Annotation#dropDB()
*/
@Override
public void dropDB() throws BaseXException
{
dropDB.execute(context);
}
/* (non-Javadoc)
* @see br.discoverconcernsinkdm.xquery.Annotation#annotation(java.lang.String, java.util.ArrayList, java.util.ArrayList)
*/
@Override
public void storableUnitAnnotation(String concern, ArrayList<String> arrayProperty) throws BaseXException, SQLException, QueryException
{
this.openDB();
for (int i=0; i<arrayProperty.size(); i++)
{
String [] var = arrayProperty.get(i).split("\\|");
String module = var[0];
String method = var[1];
String property = var[2];
String kind = var[3];
if (method.equals("-"))
{
if (kind.equals("static"))
{
String query = Query.getQuery("check-2");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("concern", concern);
proc.bind("class", module);
proc.bind("property", property);
Iter iter = proc.iter();
String rtn = "";
for(Item item; (item = iter.next()) != null;)
rtn = item.toJava().toString();
proc.close();
log.info("STATIC-IN-CLASS");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Property name: " + property);
log.info("Type of Artifact: " + kind);
log.info("Length of Return: "+rtn.length() + " Name: " + rtn);
log.info("---------------------------------------------------");
if (!rtn.equals(concern))
{
query = Query.getQuery("propertyAnnotation-2");
proc = new QueryProcessor(query, context);
String tag = "<attribute tag=\"concern\" value=\"" + concern + "\"/>";
proc.bind("tag", tag);
proc.bind("class", module);
proc.bind("property", property);
proc.bind("kind", kind);
// Execute the query
proc.execute();
proc.close();
}
}
else
{
if (kind.equals("global"))
{
String query = Query.getQuery("check-2");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("concern", concern);
proc.bind("class", module);
proc.bind("property", property);
Iter iter = proc.iter();
String rtn = "";
for(Item item; (item = iter.next()) != null;)
rtn = item.toJava().toString();
proc.close();
log.info("GLOBAL-IN-CLASS");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Property name: " + property);
log.info("Type of Artifact: " + kind);
log.info("Length of Return: "+rtn.length() + " Name: " + rtn);
log.info("---------------------------------------------------");
if (!rtn.equals(concern))
{
query = Query.getQuery("propertyAnnotation-2");
proc = new QueryProcessor(query, context);
String tag = "<attribute tag=\"concern\" value=\"" + concern + "\"/>";
proc.bind("tag", tag);
proc.bind("class", module);
proc.bind("property", property);
// Execute the query
proc.execute();
proc.close();
}
}
}
}
else
{
if (kind.equals("local") || kind.equals("static"))
{
String query = Query.getQuery("check-1");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("concern", concern);
proc.bind("class", module);
proc.bind("method", method);
proc.bind("property", property);
proc.bind("kind", kind);
Iter iter = proc.iter();
String rtn = "";
for(Item item; (item = iter.next()) != null;)
rtn = item.toJava().toString();
proc.close();
log.info("LOCAL-OR-STATIC-IN-METHOD");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Property name: " + property);
log.info("Type of Artifact: " + kind);
log.info("Length of Return: "+rtn.length() + " Name: " + rtn);
log.info("---------------------------------------------------");
if (!rtn.equals(concern))
{
query = Query.getQuery("propertyAnnotation-1");
proc = new QueryProcessor(query, context);
String tag = "<attribute tag=\"concern\" value=\"" + concern + "\"/>";
proc.bind("tag", tag);
proc.bind("class", module);
proc.bind("method", method);
proc.bind("property", property);
proc.bind("kind", kind);
// Execute the query
proc.execute();
proc.close();
//If the property belongs to a method then annotate it too
ArrayList<String> arrayMethod = new ArrayList<String>();
arrayMethod.add(module +"|"+method);
this.methodUnitAnnotation(concern, arrayMethod,true);
}
}
}
}
this.exportDB();
this.closeDB();
this.dropDB();
context.close();
}
public void methodUnitAnnotation(String concern, ArrayList<String> arrayMethod, boolean internal) throws BaseXException, SQLException, QueryException
{
if (!internal)
this.openDB();
for (int i=0; i<arrayMethod.size(); i++)
{
String [] var = arrayMethod.get(i).split("\\|");
String module = var[0];
String method = var[1];
String query = Query.getQuery("check-3");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("concern", concern);
proc.bind("class", module);
proc.bind("method", method);
Iter iter = proc.iter();
String rtn = "";
for(Item item; (item = iter.next()) != null;)
rtn = item.toJava().toString();
proc.close();
log.info("METHOD");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Length of Return: "+rtn.length() + " Name: " + rtn);
log.info("---------------------------------------------------");
if (!rtn.equals(concern))
{
query = Query.getQuery("methodAnnotation");
proc = new QueryProcessor(query, context);
String tag = "<attribute tag=\"concern\" value=\"" + concern + "\"/>";
proc.bind("tag", tag);
proc.bind("class", module);
proc.bind("method", method);
// Execute the query
proc.execute();
proc.close();
}
}
if (!internal)
{
this.exportDB();
this.closeDB();
this.dropDB();
context.close();
}
}
public void annotationRemove(ArrayList<String> arrayProperty, ArrayList<String> arrayMethod, String concern) throws BaseXException, SQLException, QueryException
{
this.openDB();
for (int i=0; i<arrayProperty.size(); i++)
{
String [] var = arrayProperty.get(i).split("\\|");
String module = var[0];
String method = var[1];
String property = var[2];
String kind = var[3];
if (method.equals("-"))
{
if (kind.equals("static"))
{
String query = Query.getQuery("propertyAnnotationRemove-2");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("class", module);
proc.bind("property", property);
proc.bind("concern", concern);
proc.bind("kind", kind);
log.info("STATIC-IN-CLASS");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Property name: " + property);
log.info("Type of Artifact: " + kind);
log.info("---------------------------------------------------");
// Execute the query
proc.execute();
proc.close();
}
else
{
if (kind.equals("global"))
{
String query = Query.getQuery("propertyAnnotationRemove-2");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("class", module);
proc.bind("property", property);
proc.bind("concern", concern);
log.info("GLOBAL-IN-CLASS");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Property name: " + property);
log.info("Type of Artifact: " + kind);
log.info("---------------------------------------------------");
// Execute the query
proc.execute();
proc.close();
}
}
}
else
{
if (kind.equals("local") || kind.equals("static"))
{
String query = Query.getQuery("propertyAnnotationRemove-1");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("class", module);
proc.bind("method", method);
proc.bind("property", property);
proc.bind("kind", kind);
proc.bind("concern", concern);
log.info("LOCAL-OR-STATIC-IN-METHOD");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("Property name: " + property);
log.info("Type of Artifact: " + kind);
log.info("---------------------------------------------------");
// Execute the query
proc.execute();
proc.close();
}
}
}
for (int i=0; i<arrayMethod.size(); i++)
{
String [] var = arrayMethod.get(i).split("\\|");
String module = var[0];
String method = var[1];
String query = Query.getQuery("methodAnnotationRemove");
QueryProcessor proc = new QueryProcessor(query, context);
proc.bind("class", module);
proc.bind("method", method);
proc.bind("concern", concern);
log.info("METHOD");
log.info("Concern name: " + concern);
log.info("Module name: " + module);
log.info("Method name: " + method);
log.info("---------------------------------------------------");
// Execute the query
proc.execute();
proc.close();
}
//Export DataBase
this.exportDB();
// Close the database context
this.closeDB();
this.dropDB();
context.close();
}
public void javaAnnotation(String projectName, ArrayList<String> concerns, String path) throws BaseXException, SQLException, QueryException
{
this.openDB();
String position = "";
String location = "";
String query = Query.getQuery("javaAnnotationMining");
QueryProcessor proc = new QueryProcessor(query, context);
ArrayList<String> arrayAddress = new ArrayList<String>();
ArrayList<String> arrayLocation = new ArrayList<String>();
ArrayList<String> packageNames = new ArrayList<String>();
ArrayList<String> methodAnnotation = new ArrayList<String>();
// Execute the query
Iter iter = proc.iter();
Item item;
while ((item = iter.next()) != null)
{
String array[] = item.toJava().toString().split("\\/");
for (int i=0; i< array.length; i++)
{
if (array[i].contains("model"))
position = position + (Integer.parseInt(array[i].split("\\.")[1]) + 1);
else
if (array[i].contains("codeElement"))
position = position + "_" + (Integer.parseInt(array[i].split("\\.")[1]) +1);
else
location = location + "_" +array[i];
}
if (!position.equals(""))
arrayAddress.add(position);
if (!position.equals(""))
arrayLocation.add(location);
position = "";
location = "";
}
proc.close();
String packageName = "";
for (int i= 0; i<arrayAddress.size() ; i++)
{
int size = (arrayAddress.get(i).split("\\_")).length;
for (int j=2; j<=size; j++)
{
query = Query.getQuery("getTypeAnnotation_"+ j);
proc = new QueryProcessor(query, context);
proc.bind("elementPosition", arrayAddress.get(i));
packageName = packageName + "." + proc.execute().toString();
}
packageNames.add(packageName.substring(1,packageName.length())+ "_"+i);
packageName = "";
proc.close();
}
this.closeDB();
//Search package in our concern library
this.createDB(path,"ConcernLibrary.xml","CL");
this.openDB();
for (String concern: concerns)
{
query = Query.getQuery("getConcernLibrary");
proc = new QueryProcessor(query, context);
proc.bind("elementPosition", concern);
// Execute the query
iter = proc.iter();
while ((item = iter.next()) != null)
{
String array = item.toJava().toString();
for (int k=0; k<packageNames.size() ; k++)
{
if (packageNames.get(k).split("\\_")[0].equals(array))
{
String loc = arrayLocation.get(Integer.parseInt(packageNames.get(k).split("\\_")[1]));
loc = loc.substring(4,loc.length());
methodAnnotation.add(loc + "_" + concern);
}
}
}
}
proc.close();
this.closeDB();
//Tag KDM with annotations
this.createDB(path, projectName + "_KDM" + ".xmi", "DBKDM");
for (int i = 0; i<methodAnnotation.size();i++)
{
this.openDB();
String locArr[] = methodAnnotation.get(i).split("\\_");
query = Query.getQuery("check-3");
proc = new QueryProcessor(query, context);
proc.bind("concern", locArr[2].toLowerCase());
proc.bind("class", locArr[1]);
proc.bind("method", locArr[0]);
iter = proc.iter();
String rtn = "";
for(Item it; (it = iter.next()) != null;)
rtn = it.toJava().toString();
proc.close();
this.closeDB();
if (!rtn.equals(locArr[2].toLowerCase()))
{
this.openDB();
query = Query.getQuery("methodAnnotation");
proc = new QueryProcessor(query, context);
proc.bind("method", locArr[0]);
proc.bind("class", locArr[1]);
String tag = "<attribute tag=\"concern\" value=\"" + locArr[2].toLowerCase() + "\"/>";
proc.bind("tag", tag);
// Execute the query
proc.execute();
proc.close();
this.exportDB();
this.closeDB();
}
}
this.dropDB();
context.close();
}
}
| [
"dsanmartins@gmail.com"
] | dsanmartins@gmail.com |
34163af1a672112867112cc6dee2bc3472690f91 | 75d109ac187241a3d061340caf75483180f2d8a6 | /src/ua/nure/kudria/practice6/part3/Parking.java | c4a37a2c4e57a1e2932386b880520c1825a25d2d | [] | no_license | ak98neon/Practice6 | c15bf1165b6c99b667dd860bcd519eeef37ed633 | 059a08aa72fbe2cf672e2bf0e0e77f1334b06a40 | refs/heads/master | 2020-04-20T20:07:49.273693 | 2019-02-05T15:38:39 | 2019-02-05T15:38:39 | 169,068,004 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,298 | java | package ua.nure.kudria.practice6.part3;
import java.util.Objects;
public class Parking {
private Object[] list;
public Parking(int size) {
this.list = new Object[size];
}
public void arrive(int pos, Object car) {
if (pos < 0 || pos > list.length - 1) {
return;
}
if (list[pos] == null) {
list[pos] = car;
return;
} else {
for (int i = pos + 1; i < list.length; i++) {
if (list[i] == null) {
list[i] = car;
return;
}
}
}
System.out.println("ะกะฒะพะฑะพะดะฝัั
ะผะตัั ะฝะตั");
}
public void depart(Object car) {
for (int i = 0; i < Objects.requireNonNull(list).length; i++) {
if (list[i] == car) {
list[i] = null;
System.out.println("ะะตััะพ ัะฒะพะฑะพะดะฝะพ!");
return;
}
}
System.out.println("Car not exist!");
}
public void print() {
for (final Object s : list) {
if (s == null) {
System.out.println("ะะตััะพ ัะฒะพะฑะพะดะฝะพ");
} else
System.out.println("ะะตััะพ ะทะฐะฝััะพ");
}
}
}
| [
"ak98nneon@gmail.com"
] | ak98nneon@gmail.com |
07d5355e063e307c89c96acd7d3d8dd09cb73ebc | 7237b62db03a44b584c156014c4ddce086c41c93 | /TapClips_android/TapClips/tapclips/src/main/java/com/elementalfoundry/tapclips/Subtitle.java | a44eaca474ef3cbe8d125365447b17129d99d8cd | [] | no_license | matthewdfay/EFRepo | 506c7e79d5720e63d27ae7a1fa6948be5117e99f | 74b29ff37c3e347fcec90d783bc454ff3fa19a91 | refs/heads/master | 2021-01-21T13:21:33.094270 | 2015-04-29T16:39:27 | 2015-04-29T16:39:27 | 34,804,600 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 294 | java | package com.elementalfoundry.tapclips;
/**
* Created by mdbranth on 5/7/14.
*/
public class Subtitle extends TCListItem {
private String mText;
public Subtitle(String text) {
super();
mText = text;
}
public String getText() {
return mText;
}
}
| [
"mattf@porch.com"
] | mattf@porch.com |
3d74c7b12afcf43adaf8e80d98849ccd70b57158 | 2f4a058ab684068be5af77fea0bf07665b675ac0 | /app/com/facebook/orca/app/AppInitializationActivityHelper.java | 767c56b128ef020cc493e5c8445312690fee839e | [] | no_license | cengizgoren/facebook_apk_crack | ee812a57c746df3c28fb1f9263ae77190f08d8d2 | a112d30542b9f0bfcf17de0b3a09c6e6cfe1273b | refs/heads/master | 2021-05-26T14:44:04.092474 | 2013-01-16T08:39:00 | 2013-01-16T08:39:00 | 8,321,708 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,436 | java | package com.facebook.orca.app;
import android.app.Activity;
import android.content.Intent;
import com.facebook.content.SecureContextHelper;
import com.facebook.orca.activity.AbstractFbActivityListener;
import com.facebook.orca.annotations.AppInitializationNotRequired;
public class AppInitializationActivityHelper extends AbstractFbActivityListener
{
private final AppInitLock a;
private final Class<? extends Activity> b;
private final SecureContextHelper c;
public AppInitializationActivityHelper(AppInitLock paramAppInitLock, SecureContextHelper paramSecureContextHelper, Class<? extends Activity> paramClass)
{
this.a = paramAppInitLock;
this.b = paramClass;
this.c = paramSecureContextHelper;
}
public void f(Activity paramActivity)
{
if (this.a.c());
while (true)
{
return;
if (paramActivity.getClass().getAnnotation(AppInitializationNotRequired.class) == null)
{
Intent localIntent1 = paramActivity.getIntent();
Intent localIntent2 = new Intent(paramActivity, this.b);
localIntent2.putExtra("return_intent", localIntent1);
this.c.a(localIntent2, paramActivity);
paramActivity.finish();
continue;
}
}
}
}
/* Location: /data1/software/jd-gui/com.facebook.katana_2.0_liqucn.com-dex2jar.jar
* Qualified Name: com.facebook.orca.app.AppInitializationActivityHelper
* JD-Core Version: 0.6.0
*/ | [
"macluz@msn.com"
] | macluz@msn.com |
caa36d3c0889256a3dcae5621e256ec614f8f7c5 | 233d39fcadac45770946010b9e232d849b2839b4 | /mobile_app/MapMe/build/preprocessed/Maps/MapMe.java | f669699afe1700588a5892eef84acba19b4b0f12 | [] | no_license | gaurav147/project | 4be0c9212ebc14136dbc59c5f855b4ae99e2e87c | 21c2de230189189113f862bd9816d5a8cf0cc44b | refs/heads/master | 2021-01-10T20:59:00.025577 | 2015-08-01T09:38:52 | 2015-08-01T09:38:52 | 40,042,209 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 8,974 | java | package Maps;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.location.*;
public class MapMe extends MIDlet implements CommandListener, LocationListener
{
private boolean midletPaused = false;
private Form mainForm;
private StringItem strLat;
private StringItem strLon;
private StringItem strAlt;
private Command cmdExit;
private Command cmdLocateMe;
private Command cmdMapMe;
private Command cmdSaveMe;
private Command cmdAboutMe;
private Command start;
private Command stop;
private String URL = "http://localhost/Mobile/LocationSaver.php";
private int count = 0;
private LocationProvider locationProvider = null;
public Form getmainForm()
{
if(this.mainForm == null)
{
this.mainForm = new Form("Map Me !!",new Item[] { getstrLat(), getStrLon(), getstrAlt() });
this.mainForm.setCommandListener(this);
this.mainForm.addCommand(this.getcmdLocateMe());
this.mainForm.addCommand(this.getcmdMapMe());
this.mainForm.addCommand(this.getcmdSaveMe());
this.mainForm.addCommand(this.getcmdAboutMe());
this.mainForm.addCommand(this.getcmdExit());
this.mainForm.addCommand(this.getStart());
try
{
Criteria cr = new Criteria();
cr.setHorizontalAccuracy(Criteria.NO_REQUIREMENT);
cr.setVerticalAccuracy(Criteria.NO_REQUIREMENT);
cr.setCostAllowed(true);
cr.setPreferredPowerConsumption(Criteria.POWER_USAGE_HIGH);
this.locationProvider = LocationProvider.getInstance(cr);
}
catch (Exception e)
{
exitMIDlet();
}
}
return this.mainForm;
}
public void locationUpdated(LocationProvider provider, Location location)
{
if (location != null && location.isValid())
{
QualifiedCoordinates qc = location.getQualifiedCoordinates();
boolean isSaved = Helper.saveLocation(URL, qc.getLatitude(), qc.getLongitude());
String text = isSaved == true ? "Location Saved " + ++count : "Failed";
strLat.setText(text);
}
}
public void providerStateChanged(LocationProvider lp, int i)
{
}
public StringItem getstrAlt()
{
if(this.strAlt == null)
{
this.strAlt = new StringItem("","");
}
return this.strAlt;
}
public StringItem getstrLat()
{
if(this.strLat == null)
{
this.strLat = new StringItem("","");
}
return this.strLat;
}
public StringItem getStrLon()
{
if(this.strLon == null)
{
this.strLon = new StringItem("","");
}
return this.strLon;
}
public Command getcmdExit()
{
if (this.cmdExit == null) {
this.cmdExit = new Command("Exit", Command.EXIT, 0);
}
return this.cmdExit;
}
public Command getcmdLocateMe()
{
if (this.cmdLocateMe == null) {
this.cmdLocateMe = new Command("Pin Me", Command.SCREEN, 0);
}
return this.cmdLocateMe;
}
public Command getcmdMapMe()
{
if (this.cmdMapMe == null) {
this.cmdMapMe = new Command("Map", Command.SCREEN, 0);
}
return this.cmdMapMe;
}
public Command getcmdSaveMe()
{
if (this.cmdSaveMe == null) {
this.cmdSaveMe = new Command("Save", Command.SCREEN, 0);
}
return this.cmdSaveMe;
}
public Command getcmdAboutMe()
{
if (this.cmdAboutMe == null) {
this.cmdAboutMe = new Command("About Me", Command.SCREEN, 0);
}
return this.cmdAboutMe;
}
public Command getStart()
{
if (this.start == null)
{
this.start = new Command("Start", Command.SCREEN, 1);
}
return this.start;
}
public Command getStop()
{
if (this.stop == null)
{
this.stop = new Command("Stop", Command.SCREEN, 1);
}
return this.stop;
}
public void startApp()
{
if (midletPaused) {
resumeMIDlet ();
} else {
initialize ();
startMIDlet ();
}
midletPaused = false;
}
public void commandAction(Command command, Displayable displayable)
{
if (displayable == this.mainForm)
{
if (command == this.cmdExit)
{
exitMIDlet();
}
else if(command == this.getcmdAboutMe())
{
String message = "summer internship(System time: " + Helper.getNowInDate();
Alert alert = new Alert("About", message, null, AlertType.INFO);
alert.setTimeout(Alert.FOREVER);
this.getDisplay().setCurrent(alert);
}
else if(command == this.getcmdLocateMe())
{
try
{
double []arr = Helper.getLocation(this.locationProvider);
String text = "Lat: " + Double.toString(arr[0])
+ " Lon:" + Double.toString(arr[1])
+ " Alt:" + Double.toString(arr[2]);
this.strLat.setText(text);
}
catch (Exception e)
{
this.strLat.setText(e.getMessage());
}
}
else if(command == this.getcmdMapMe())
{
try
{
double []arr = Helper.getLocation(this.locationProvider);
this.getDisplay().setCurrent(new MapViewer(this,this.mainForm,arr[0],arr[1]));
}
catch(Exception ex)
{
this.strLat.setText(ex.getMessage());
}
}
else if(command == this.getcmdSaveMe())
{
try
{
boolean result = true;
if (result)
{
this.strLat.setText("location saved in database!!");
}
else
{
this.strLat.setText("Failed to save location!!");
}
}
catch (Exception e)
{
this.strLat.setText(e.getMessage());
}
}
else if (command == this.getStart())
{
this.mainForm.removeCommand(this.getStart());
new Thread()
{
public void run()
{
locationProvider.setLocationListener(MapMe.this, 10, -1, -1);
}
}.start();
this.count = 0;
this.mainForm.addCommand(this.getStop());
}
else if (command == this.getStop())
{
this.mainForm.removeCommand(this.getStop());
new Thread()
{
public void run()
{
locationProvider.setLocationListener(null, -1, -1, -1);
}
}.start();
this.mainForm.addCommand(this.getStart());
this.strLat.setText("");
}
}
}
public void pauseApp()
{
midletPaused = true;
}
public void resumeMIDlet()
{
}
public void destroyApp(boolean unconditional)
{
}
public Display getDisplay ()
{
return Display.getDisplay(this);
}
public void switchDisplayable(Alert alert, Displayable nextDisplayable)
{
Display display = getDisplay();
if (alert == null) {
display.setCurrent(nextDisplayable);
} else {
display.setCurrent(alert, nextDisplayable);
}
}
public void startMIDlet()
{
switchDisplayable(null, getmainForm());
}
public void exitMIDlet()
{
switchDisplayable (null, null);
destroyApp(true);
notifyDestroyed();
}
private void initialize()
{
}
}
| [
"gaurav.tomer14@gmail.com"
] | gaurav.tomer14@gmail.com |
91bcda7b6750e28117d97094ffd3527e0e6eee99 | 45be8c8e27bf82789c904cf6e6aa6b50606ed25a | /FairyBook/src/main/java/global/sesoc/fairybook/util/PageNavigator.java | a6327d2fdd0c1f2a4a4cf38d823b0e6db1432291 | [] | no_license | euntas/FairyBook | dc70ea89d3ed57d3b6b082cf463ad3269d06a976 | 91a8dcb3e8fb069dc9fdf8b21a09c41e0399251c | refs/heads/master | 2021-06-06T16:40:03.552760 | 2017-08-02T01:23:00 | 2017-08-02T01:23:00 | 85,143,270 | 0 | 0 | null | 2021-05-24T13:31:29 | 2017-03-16T02:28:07 | JavaScript | UTF-8 | Java | false | false | 4,249 | java | package global.sesoc.fairybook.util;
/**
* ๊ฒ์ํ ํ์ด์ง ์ฒ๋ฆฌ ํด๋์ค
*/
public class PageNavigator {
//ํ์ด์ง ๊ด๋ จ ์ ๋ณด
private int countPerPage; //ํ์ด์ง๋น ๊ธ๋ชฉ๋ก ์
private int pagePerGroup; //๊ทธ๋ฃน๋น ํ์ด์ง ์ (5๊ฐ์ฉ ๋ณด์ฌ์ฃผ๊ฒ ๋ค)
private int currentPage; //ํ์ฌ ํ์ด์ง (์ต๊ทผ ๊ธ์ด 1๋ถํฐ ์์)
private int totalRecordsCount; //์ ์ฒด ๊ธ ์
private int totalPageCount; //์ ์ฒด ํ์ด์ง ์
private int currentGroup; //ํ์ฌ ๊ทธ๋ฃน (์ต๊ทผ ๊ทธ๋ฃน์ด 0๋ถํฐ ์์)
private int startPageGroup; //ํ์ฌ ๊ทธ๋ฃน์ ์ฒซ ํ์ด์ง
private int endPageGroup; //ํ์ฌ ๊ทธ๋ฃน์ ๋ง์ง๋ง ํ์ด์ง
private int startRecord; //์ ์ฒด ๋ ์ฝ๋ ์ค ํ์ฌ ํ์ด์ง ์ฒซ ๊ธ์ ์์น (0๋ถํฐ ์์)
/*
* ์์ฑ์
*/
public PageNavigator(int countPerPage, int pagePerGroup, int currentPage, int totalRecordsCount) {
//ํ์ด์ง๋น ๊ธ ์, ๊ทธ๋ฃน๋น ํ์ด์ง ์, ํ์ฌ ํ์ด์ง, ์ ์ฒด ๊ธ ์๋ฅผ ์ ๋ฌ๋ฐ์
this.countPerPage = countPerPage;
this.pagePerGroup = pagePerGroup;
this.totalRecordsCount = totalRecordsCount;
//์ ์ฒด ํ์ด์ง ์ (0~9/ 10~19/ 20~29/....)
totalPageCount = (totalRecordsCount + countPerPage - 1) / countPerPage;
//์ ๋ฌ๋ ํ์ฌ ํ์ด์ง๊ฐ 1๋ณด๋ค ์์ผ๋ฉด ํ์ฌํ์ด์ง๋ฅผ 1ํ์ด์ง๋ก ์ง์
if (currentPage < 1) currentPage = 1;
//์ ๋ฌ๋ ํ์ฌ ํ์ด์ง๊ฐ ๋ง์ง๋ง ํ์ด์ง๋ณด๋ค ํฌ๋ฉด ํ์ฌํ์ด์ง๋ฅผ ๋ง์ง๋ง ํ์ด์ง๋ก ์ง์
if (currentPage > totalPageCount) currentPage = totalPageCount;
this.currentPage = currentPage;
//ํ์ฌ ๊ทธ๋ฃน
currentGroup = (currentPage - 1) / pagePerGroup;
//ํ์ฌ ๊ทธ๋ฃน์ ์ฒซ ํ์ด์ง
startPageGroup = currentGroup * pagePerGroup + 1;
//ํ์ฌ ๊ทธ๋ฃน์ ์ฒซ ํ์ด์ง๊ฐ 1๋ณด๋ค ์์ผ๋ฉด 1๋ก ์ฒ๋ฆฌ
startPageGroup = startPageGroup < 1 ? 1 : startPageGroup;
//ํ์ฌ ๊ทธ๋ฃน์ ๋ง์ง๋ง ํ์ด์ง
endPageGroup = startPageGroup + pagePerGroup - 1;
//ํ์ฌ ๊ทธ๋ฃน์ ๋ง์ง๋ง ํ์ด์ง๊ฐ ์ ์ฒด ํ์ด์ง ์๋ณด๋ค ์์ผ๋ฉด ์ ์ฒดํ์ด์ง ์๋ฅผ ๋ง์ง๋ง์ผ๋ก.
endPageGroup = endPageGroup < totalPageCount ? endPageGroup : totalPageCount;
//์ ์ฒด ๋ ์ฝ๋ ์ค ํ์ฌ ํ์ด์ง ์ฒซ ๊ธ์ ์์น
startRecord = (currentPage - 1) * countPerPage;
}
/*
* Getters and Setters
*/
public int getCountPerPage() {
return countPerPage;
}
public void setCountPerPage(int countPerPage) {
this.countPerPage = countPerPage;
}
public int getPagePerGroup() {
return pagePerGroup;
}
public void setPagePerGroup(int pagePerGroup) {
this.pagePerGroup = pagePerGroup;
}
public int getCurrentPage() {
return currentPage;
}
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
public int getTotalRecordsCount() {
return totalRecordsCount;
}
public void setTotalRecordsCount(int totalRecordsCount) {
this.totalRecordsCount = totalRecordsCount;
}
public int getTotalPageCount() {
return totalPageCount;
}
public void setTotalPageCount(int totalPageCount) {
this.totalPageCount = totalPageCount;
}
public int getCurrentGroup() {
return currentGroup;
}
public void setCurrentGroup(int currentGroup) {
this.currentGroup = currentGroup;
}
public int getStartPageGroup() {
return startPageGroup;
}
public void setStartPageGroup(int startPageGroup) {
this.startPageGroup = startPageGroup;
}
public int getEndPageGroup() {
return endPageGroup;
}
public void setEndPageGroup(int endPageGroup) {
this.endPageGroup = endPageGroup;
}
public int getStartRecord() {
return startRecord;
}
public void setStartRecord(int startRecord) {
this.startRecord = startRecord;
}
@Override
public String toString() {
return "PageNavigator [countPerPage=" + countPerPage + ", pagePerGroup=" + pagePerGroup + ", currentPage="
+ currentPage + ", totalRecordsCount=" + totalRecordsCount + ", totalPageCount=" + totalPageCount
+ ", currentGroup=" + currentGroup + ", startPageGroup=" + startPageGroup + ", endPageGroup="
+ endPageGroup + ", startRecord=" + startRecord + "]";
}
}
| [
"kita@kita-PC"
] | kita@kita-PC |
f5175a5e31f794e3ca96fe0c42b0f7889bf41638 | c30020c4978603391a41a8eefc98e4478ba9f91b | /src/main/resources/kr/or/kpetro/svr/mdwr/processor/ProcessorController.java | 95257387367b41efed7b4da47abfd6a7ee06ec3e | [] | no_license | moriac-min/test5 | b38be8b6538b9811c5bd1d6f74ac2687f10e9c4b | a40dcbdbe6e1e303b1eb8f1b97f301725a66861d | refs/heads/master | 2021-01-17T14:02:29.155318 | 2016-08-01T02:24:28 | 2016-08-01T02:24:28 | 64,628,728 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 989 | java | package kr.or.kpetro.svr.mdwr.processor;
import kr.or.kpetro.svr.cmm.service.RequestVO;
import kr.or.kpetro.svr.cmm.service.ResponseVO;
import kr.or.kpetro.svr.service.BusinessPlaceLicenseVO;
import org.springframework.ui.ModelMap;
public abstract class ProcessorController {
//public abstract EgovMap requestParse(HttpServletRequest request)throws Throwable;
/**ํ๋ก์ธ์ค ๋น์ฆ๋์ค ๋ก์ง ์ฒ๋ฆฌ์*/
public abstract ResponseVO process(RequestVO reqvo, BusinessPlaceLicenseVO licensevo, ModelMap model)throws Throwable;
public ResponseVO doProcess(RequestVO reqvo, BusinessPlaceLicenseVO licensevo,
ModelMap model) throws Throwable{
// TODO Auto-generated method stub
// ๋์ ์์์๊ฐ ํ๊ฒฝ ์ค์ ๊ฐ์ ์ฝ์ด๋ค์ด๊ณ
// ๋๋ ๊ฐ์ ๋ฐ์, ํด๋ผ์ด์ธํธ์ ์ ๋ฌํ๋ค.
model.clear();
// ์๋น์ค์์ด๋parse
reqvo.addBusinessInfo();
ResponseVO resvo = process(reqvo, licensevo, model);
return resvo; // ์์์ด ๊ตฌํ
}
}
| [
"seminhi@naver.com"
] | seminhi@naver.com |
e60d21bce633f7de98f9fbfaeef37daac4a139cb | da68a9a67d09d9c9de24a3000aa2ba385b284577 | /CalculadoraDMO1/app/src/main/java/br/edu/ifsp/arq/dmos5_2020s1/calculadoradmo/model/Calculadora.java | e5f95c83edf19d5fbfeeccdcae86fdee25c8e266 | [] | no_license | RubensAlvesNeto/ExercicioDMO_22_03 | 38f2c66de36d89d22bb88e168940a008b240a4e8 | 252108d4ecce7d99f39c6ca0b17b2a2211e64928 | refs/heads/master | 2021-04-16T02:56:08.556228 | 2020-03-23T02:55:54 | 2020-03-23T02:55:54 | 249,321,834 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,457 | java | package br.edu.ifsp.arq.dmos5_2020s1.calculadoradmo.model;
import br.edu.ifsp.arq.dmos5_2020s1.calculadoradmo.constants.Constantes;
public class Calculadora {
private static Calculadora sCalculadora = null;
private float memoria;
private int operacao;
private Calculadora() {
c();
}
public static Calculadora getInstance() {
if(sCalculadora == null){
sCalculadora = new Calculadora();
}
return sCalculadora;
}
public void c(){
memoria = 0;
operacao = Constantes.NULO;
}
public float calcular(int operacao, float valor) {
if (this.operacao == Constantes.NULO) {
this.operacao = operacao;
this.memoria = valor;
} else {
switch (this.operacao) {
case Constantes.ADICAO:
memoria += valor;
break;
case Constantes.SUBTRACAO:
memoria -= valor;
break;
case Constantes.MULTIPLICACAO:
memoria *= valor;
break;
case Constantes.DIVISAO:
memoria /= valor;
break;
default:
break;
}
this.operacao = operacao;
}
return memoria;
}
public void setOperacao( int oper ){
this.operacao = oper;
}
}
| [
"rubensalves5436@gmail.com"
] | rubensalves5436@gmail.com |
38118734cc828bbc0c3a4ea5733ee2a27cea7009 | d2cb1f4f186238ed3075c2748552e9325763a1cb | /methods_all/nonstatic_methods/java_net_ProxySelector_wait_long.java | 19073be1e8b6d2c69da6715575ac7d106fe67367 | [] | no_license | Adabot1/data | 9e5c64021261bf181b51b4141aab2e2877b9054a | 352b77eaebd8efdb4d343b642c71cdbfec35054e | refs/heads/master | 2020-05-16T14:22:19.491115 | 2019-05-25T04:35:00 | 2019-05-25T04:35:00 | 183,001,929 | 4 | 0 | null | null | null | null | UTF-8 | Java | false | false | 160 | java | class java_net_ProxySelector_wait_long{ public static void function() {java.net.ProxySelector obj = new java.net.ProxySelector();obj.wait(305205669044447229);}} | [
"peter2008.ok@163.com"
] | peter2008.ok@163.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.