Example usage for java.math BigInteger valueOf

List of usage examples for java.math BigInteger valueOf

Introduction

In this page you can find the example usage for java.math BigInteger valueOf.

Prototype

private static BigInteger valueOf(int val[]) 

Source Link

Document

Returns a BigInteger with the given two's complement representation.

Usage

From source file:NaraePreference.java

public BigInteger getValue(String key, BigInteger defaultvalue) {
    try {/*  ww  w.  j a  va  2s  .c  om*/
        long str = pref.getLong(key, 0);
        return BigInteger.valueOf(str);
    } catch (Exception e) {
        return defaultvalue;
    }
}

From source file:com.abiquo.am.services.download.OVFDocumentFetch.java

private EnvelopeType fixDiskFormtatUriAndFileSizes(final EnvelopeType envelope, final String ovfId)
        throws SectionNotPresentException, InvalidSectionException {

    DiskSectionType diskSection = OVFEnvelopeUtils.getSection(envelope, DiskSectionType.class);

    if (diskSection.getDisk().size() != 1) {
        final String message = "abicloud only supports single disk definition on the OVF, the current envelope contains multiple disk";
        throw new InvalidSectionException(message);
    }//w ww  .  ja v  a2  s .c  o  m

    VirtualDiskDescType vdisk = diskSection.getDisk().get(0);

    String formatUri = vdisk.getFormat();

    if (StringUtils.isEmpty(formatUri)) {
        final String message = "Missing ''format'' attribute for the Disk element";
        throw new InvalidSectionException(message);
    }

    DiskFormatType format = DiskFormatType.fromURI(formatUri);

    if (format == null) // the format URI isn't on the abicloud enumeration. FIX it
    {
        // vbox/vmware
        // http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized
        // abiquo
        // http://www.vmware.com/technical-resources/interfaces/vmdk_access.html#streamOptimized

        if (formatUri.contains("interfaces/specifications/vmdk.html")) {
            formatUri = formatUri.replace("interfaces/specifications/vmdk.html",
                    "technical-resources/interfaces/vmdk_access.html");

            format = DiskFormatType.fromURI(formatUri);

            if (format == null) {
                throw new InvalidSectionException(String.format("Invalid disk format type [%s]", formatUri));
            }

            vdisk.setFormat(formatUri);
        }

    }

    try {
        for (FileType ftype : envelope.getReferences().getFile()) {
            if (ftype.getSize() == null) {
                String fileUrl = getFileUrl(ftype.getHref(), ovfId);
                Long size = new ExternalHttpConnection().headFile(fileUrl);

                ftype.setSize(BigInteger.valueOf(size));
            }
        }
    } catch (Exception e) {
        throw new InvalidSectionException(String.format(
                "Invalid File References section "
                        + "(check all the files on the OVF document contains the ''size'' attribute):\n",
                e.toString()));
    }

    return envelope;
}

From source file:jp.aegif.nemaki.cmis.factory.CmisService.java

/**
 * This method is customized based on OpenCMIS code
 *///from   w  ww.ja va  2s. c o  m
@Override
protected ObjectInfo getObjectInfoIntern(String repositoryId, ObjectData object) {
    // if the object has no properties, stop here
    if (object.getProperties() == null || object.getProperties().getProperties() == null) {
        throw new CmisRuntimeException("No properties!");
    }

    ObjectInfoImpl info = new ObjectInfoImpl();

    // get the repository info
    RepositoryInfo repositoryInfo = getRepositoryInfo(repositoryId, null);

    // general properties
    info.setObject(object);
    info.setId(object.getId());
    info.setName(getStringProperty(object, PropertyIds.NAME));
    info.setCreatedBy(getStringProperty(object, PropertyIds.CREATED_BY));
    info.setCreationDate(getDateTimeProperty(object, PropertyIds.CREATED_BY));
    info.setLastModificationDate(getDateTimeProperty(object, PropertyIds.LAST_MODIFICATION_DATE));
    info.setTypeId(getIdProperty(object, PropertyIds.OBJECT_TYPE_ID));
    info.setBaseType(object.getBaseTypeId());

    // versioning
    info.setIsCurrentVersion(object.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT);
    info.setWorkingCopyId(null);
    info.setWorkingCopyOriginalId(null);

    info.setVersionSeriesId(getIdProperty(object, PropertyIds.VERSION_SERIES_ID));
    if (info.getVersionSeriesId() != null) {
        Boolean isLatest = getBooleanProperty(object, PropertyIds.IS_LATEST_VERSION);
        info.setIsCurrentVersion(isLatest == null ? true : isLatest.booleanValue());

        Boolean isCheckedOut = getBooleanProperty(object, PropertyIds.IS_VERSION_SERIES_CHECKED_OUT);
        if (isCheckedOut != null && isCheckedOut.booleanValue()) {
            info.setWorkingCopyId(getIdProperty(object, PropertyIds.VERSION_SERIES_CHECKED_OUT_ID));

            // get latest version
            // // Nemaki Cusomization START ////
            /*
             * List<ObjectData> versions = getAllVersions(repositoryId,
             * object.getId(), info.getVersionSeriesId(), null,
             * Boolean.FALSE, null); if (versions != null && versions.size()
             * > 0) {
             * info.setWorkingCopyOriginalId(versions.get(0).getId()); }
             */

            // NOTE:Spec2.2.7.6 only says the first element of
            // getAllVersions MUST be PWC.
            // When isCheckedOut = true, PWC MUST exsits, and
            // cmis:versionSeriesCheckedOutId is PWC id(2.1.13.5.1).
            info.setWorkingCopyOriginalId(getIdProperty(object, PropertyIds.VERSION_SERIES_CHECKED_OUT_ID));
            // // Nemaki Cusomization END ////
        }
    }

    // content
    String fileName = getStringProperty(object, PropertyIds.CONTENT_STREAM_FILE_NAME);
    String mimeType = getStringProperty(object, PropertyIds.CONTENT_STREAM_MIME_TYPE);
    String streamId = getIdProperty(object, PropertyIds.CONTENT_STREAM_ID);
    BigInteger length = getIntegerProperty(object, PropertyIds.CONTENT_STREAM_LENGTH);
    boolean hasContent = fileName != null || mimeType != null || streamId != null || length != null;
    if (hasContent) {
        info.setHasContent(hasContent);
        info.setContentType(mimeType);
        info.setFileName(fileName);
    } else {
        info.setHasContent(false);
        info.setContentType(null);
        info.setFileName(null);
    }

    // parents
    if (object.getBaseTypeId() == BaseTypeId.CMIS_RELATIONSHIP) {
        info.setHasParent(false);
    } else if (object.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {
        info.setHasParent(!object.getId().equals(repositoryInfo.getRootFolderId()));
        // // Nemaki Cusomization START ////
        /*
         * } else { try { List<ObjectParentData> parents =
         * getObjectParents(repositoryId, object.getId(), null,
         * Boolean.FALSE, IncludeRelationships.NONE, "cmis:none",
         * Boolean.FALSE, null); info.setHasParent(parents.size() > 0); }
         * catch (CmisInvalidArgumentException e) {
         * info.setHasParent(false); } }
         */
    } else {
        String objecTypeId = getIdProperty(object, PropertyIds.OBJECT_TYPE_ID);
        TypeDefinition typeDefinition = getTypeDefinition(repositoryId, objecTypeId, null);

        if (typeDefinition.isFileable()) {
            boolean unfiling = (repositoryInfo.getCapabilities().isUnfilingSupported() == null) ? false
                    : repositoryInfo.getCapabilities().isUnfilingSupported();
            if (unfiling) {
                List<ObjectParentData> parents = getObjectParents(repositoryId, object.getId(), null,
                        Boolean.FALSE, IncludeRelationships.NONE, "cmis:none", Boolean.FALSE, null);
                info.setHasParent(parents != null && parents.size() >= 0);
            } else {
                info.setHasParent(true);
            }
        } else {
            info.setHasParent(false);
        }
    }
    // // Nemaki Cusomization END ////

    // policies and relationships
    info.setSupportsRelationships(false);
    info.setSupportsPolicies(false);

    TypeDefinitionList baseTypesList = getTypeChildren(repositoryId, null, Boolean.FALSE, BigInteger.valueOf(4),
            BigInteger.ZERO, null);
    for (TypeDefinition type : baseTypesList.getList()) {
        if (BaseTypeId.CMIS_RELATIONSHIP.value().equals(type.getId())) {
            info.setSupportsRelationships(true);
        } else if (BaseTypeId.CMIS_POLICY.value().equals(type.getId())) {
            info.setSupportsPolicies(true);
        }
    }

    // renditions
    info.setRenditionInfos(null);
    List<RenditionData> renditions = object.getRenditions();
    if (renditions != null && renditions.size() > 0) {
        List<RenditionInfo> renditionInfos = new ArrayList<RenditionInfo>();
        for (RenditionData rendition : renditions) {
            RenditionInfoImpl renditionInfo = new RenditionInfoImpl();
            renditionInfo.setId(rendition.getStreamId());
            renditionInfo.setKind(rendition.getKind());
            renditionInfo.setContentType(rendition.getMimeType());
            renditionInfo.setTitle(rendition.getTitle());
            renditionInfo.setLength(rendition.getBigLength());
            renditionInfos.add(renditionInfo);
        }
        info.setRenditionInfos(renditionInfos);
    }

    // relationships
    info.setRelationshipSourceIds(null);
    info.setRelationshipTargetIds(null);
    List<ObjectData> relationships = object.getRelationships();
    if (relationships != null && relationships.size() > 0) {
        List<String> sourceIds = new ArrayList<String>();
        List<String> targetIds = new ArrayList<String>();
        for (ObjectData relationship : relationships) {
            String sourceId = getIdProperty(relationship, PropertyIds.SOURCE_ID);
            String targetId = getIdProperty(relationship, PropertyIds.TARGET_ID);
            if (object.getId().equals(sourceId)) {
                sourceIds.add(relationship.getId());
            }
            if (object.getId().equals(targetId)) {
                targetIds.add(relationship.getId());
            }
        }
        if (sourceIds.size() > 0) {
            info.setRelationshipSourceIds(sourceIds);
        }
        if (targetIds.size() > 0) {
            info.setRelationshipTargetIds(targetIds);
        }
    }

    // global settings
    info.setHasAcl(false);
    info.setSupportsDescendants(false);
    info.setSupportsFolderTree(false);

    RepositoryCapabilities capabilities = repositoryInfo.getCapabilities();
    if (capabilities != null) {
        info.setHasAcl(capabilities.getAclCapability() == CapabilityAcl.DISCOVER
                || capabilities.getAclCapability() == CapabilityAcl.MANAGE);
        if (object.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {
            info.setSupportsDescendants(Boolean.TRUE.equals(capabilities.isGetDescendantsSupported()));
            info.setSupportsFolderTree(Boolean.TRUE.equals(capabilities.isGetFolderTreeSupported()));
        }
    }

    return info;
}

From source file:com.flexive.core.storage.genericSQL.GenericTreeStorageSpreaded.java

/**
 * Creates space for an additional amount of nodes at the specified position in the specified node.
 *
 * @param con        an open and valid connection
 * @param seq        reference to the sequencer
 * @param mode       tree mode//from  w  ww  . jav a 2  s  .c o  m
 * @param nodeId     the node to work on
 * @param position   the position within the child nodes (0 based)
 * @param additional the amount of additional nodes to make space for
 * @return the used spacing
 * @throws FxApplicationException on errors
 */
public BigInteger makeSpace(Connection con, SequencerEngine seq, FxTreeMode mode, long nodeId, int position,
        final int additional) throws FxApplicationException {
    FxTreeNodeInfoSpreaded nodeInfo = (FxTreeNodeInfoSpreaded) getTreeNodeInfo(con, mode, nodeId);
    BigInteger boundaries[] = getBoundaries(con, nodeInfo, position);

    int totalChildCount = nodeInfo.getTotalChildCount() + additional;
    boolean hasSpace = nodeInfo.hasSpaceFor(totalChildCount, 2);
    /*if( hasSpace )
    return nodeInfo.getSpacing(totalChildCount);*/

    // Determine node to work on
    while (!hasSpace) {
        nodeInfo = (FxTreeNodeInfoSpreaded) getTreeNodeInfo(con, mode, nodeInfo.getParentId());
        totalChildCount += nodeInfo.getTotalChildCount() + 1;
        hasSpace = nodeInfo.hasSpaceFor(totalChildCount, 2);
        if (!hasSpace && nodeInfo.isRoot()) {
            throw new FxUpdateException("ex.tree.makeSpace.failed");
        }
    }

    // Allocate/Reorganize space
    BigInteger spacing = nodeInfo.getSpacing(totalChildCount);
    int spaceCount = (additional * 2) + 1;
    BigInteger insertSpace = spacing.multiply(BigInteger.valueOf(spaceCount));
    insertSpace = insertSpace.add(BigInteger.valueOf(additional * 2));

    reorganizeSpace(con, seq, mode, mode, nodeInfo.getId(), false, spacing, null, nodeInfo, position,
            insertSpace, boundaries, 0, null, false, false, false);
    return spacing;
}

From source file:jp.aegif.nemaki.cmis.service.impl.ObjectServiceImpl.java

@Override
public List<RenditionData> getRenditions(CallContext callContext, String repositoryId, String objectId,
        String renditionFilter, BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) {

    Lock lock = threadLockService.getReadLock(repositoryId, objectId);
    try {/*from   w ww.jav  a 2 s .c om*/
        lock.lock();

        List<Rendition> renditions = contentService.getRenditions(repositoryId, objectId);

        List<RenditionData> results = new ArrayList<RenditionData>();
        for (Rendition rnd : renditions) {
            RenditionDataImpl data = new RenditionDataImpl(rnd.getId(), rnd.getMimetype(),
                    BigInteger.valueOf(rnd.getLength()), rnd.getKind(), rnd.getTitle(),
                    BigInteger.valueOf(rnd.getWidth()), BigInteger.valueOf(rnd.getHeight()),
                    rnd.getRenditionDocumentId());
            results.add(data);
        }
        return results;
    } finally {
        lock.unlock();
    }
}

From source file:com.cognitect.transit.TransitMPTest.java

public void testReadCmap() throws IOException {
    final String[] ratioRep = { "~n1", "~n2" };
    final int[] mints = { 1, 2, 3 };

    final Map ratio = new HashMap() {
        {/*from   w  w  w  .  j  a va 2  s  . com*/
            put("~#ratio", ratioRep);
        }
    };

    final Map list = new HashMap() {
        {
            put("~#list", mints);
        }
    };

    final List things = new ArrayList() {
        {
            add(ratio);
            add(1);
            add(list);
            add(2);
        }
    };

    final Map thing = new HashMap() {
        {
            put("~#cmap", things);
        }
    };

    Map m = readerOf(thing).read();

    assertEquals(2, m.size());

    Iterator<Map.Entry> i = m.entrySet().iterator();
    while (i.hasNext()) {
        Map.Entry e = i.next();
        if ((Long) e.getValue() == 1L) {
            Ratio r = (Ratio) e.getKey();
            assertEquals(BigInteger.valueOf(1), r.getNumerator());
            assertEquals(BigInteger.valueOf(2), r.getDenominator());
        } else if ((Long) e.getValue() == 2L) {
            List l = (List) e.getKey();
            assertEquals(1L, l.get(0));
            assertEquals(2L, l.get(1));
            assertEquals(3L, l.get(2));
        }
    }
}

From source file:co.rsk.peg.BridgeSerializationUtilsTest.java

@Test
public void deserializePendingFederation() throws Exception {
    PowerMockito.mockStatic(RLP.class);
    mock_RLP_decode2(InnerListMode.NONE);

    byte[][] publicKeyBytes = Arrays.asList(100, 200, 300, 400, 500, 600).stream()
            .map(k -> BtcECKey.fromPrivate(BigInteger.valueOf(k))).sorted(BtcECKey.PUBKEY_COMPARATOR)
            .map(k -> k.getPubKey()).toArray(byte[][]::new);

    StringBuilder sampleBuilder = new StringBuilder();
    sampleBuilder.append("06212121212121"); // 6 elements of 33 bytes (0x21 bytes) each.
    for (int i = 0; i < publicKeyBytes.length; i++) {
        sampleBuilder.append(Hex.toHexString(publicKeyBytes[i]));
    }// w  w  w . j av a2 s.c om
    byte[] sample = Hex.decode(sampleBuilder.toString());

    PendingFederation deserializedPendingFederation = BridgeSerializationUtils
            .deserializePendingFederation(sample);

    Assert.assertEquals(6, deserializedPendingFederation.getPublicKeys().size());
    for (int i = 0; i < 6; i++) {
        Assert.assertTrue(Arrays.equals(publicKeyBytes[i],
                deserializedPendingFederation.getPublicKeys().get(i).getPubKey()));
    }
}

From source file:energy.usef.core.service.business.CorePlanboardBusinessServiceTest.java

@Test
public void testStorePrognosisWithAplan() {
    // given/*from w w  w .ja v a  2s . c  om*/
    Random random = new Random();
    Prognosis prognosis = new Prognosis();
    prognosis.getPTU().addAll(IntStream.rangeClosed(1, 96).mapToObj(elem -> {
        PTU ptuDto = new PTU();
        ptuDto.setPower(BigInteger.valueOf(random.nextInt(500)));
        ptuDto.setStart(BigInteger.valueOf(elem));
        return ptuDto;
    }).collect(Collectors.toList()));
    prognosis.setPeriod(new LocalDate());
    prognosis.setSequence(random.nextLong());
    prognosis.setType(PrognosisType.A_PLAN);

    PowerMockito.when(connectionGroupRepository.find(Matchers.anyString()))
            .thenReturn(PowerMockito.mock(ConnectionGroup.class));
    // when
    corePlanboardBusinessService.storePrognosis("agr.usef-example.com", prognosis, DocumentType.A_PLAN,
            DocumentStatus.PROCESSED, "agr.usef-example.com", null, false);

    // then
    Mockito.verify(ptuPrognosisRepository, Mockito.times(96)).persist(Matchers.any(PtuPrognosis.class));
}

From source file:io.udvi.amqp.mq.transport.link.CAMQPLinkEndpoint.java

/**
 * Process an incoming Link attach frame. For link establishment initiator,
 * nothing needs do be done. Otherwise, set the initial delivery count and
 * source or target address from the incoming attach frame. Send back an
 * attach frame,/*from   ww  w  . j a v a  2  s .com*/
 *
 * @param data
 * @param isInitiator
 */
void processAttachReceived(CAMQPControlAttach data, boolean isInitiator) {
    remoteLinkHandle = data.getHandle();

    if (isInitiator)
        return;

    linkHandle = CAMQPLinkManager.getNextLinkHandle();

    linkName = data.getName();

    if (getRole() == LinkRole.LinkReceiver) {
        if (data.isSetInitialDeliveryCount())
            deliveryCount = data.getInitialDeliveryCount();
    }

    /*
     * Override endpointPolicy with that received in the ATTACH frame from
     * peer
     */
    long maxMessageSize = CAMQPLinkConstants.DEFAULT_MAX_MESSAGE_SIZE;
    if (data.isSetMaxMessageSize()) {
        maxMessageSize = data.getMaxMessageSize().longValue();
    }

    int sndSettleMode = CAMQPConstants.SENDER_SETTLE_MODE_MIXED;
    if (data.isSetSndSettleMode()) {
        sndSettleMode = data.getSndSettleMode();
    }

    int rcvSettleMode = CAMQPConstants.RECEIVER_SETTLE_MODE_SECOND;
    if (data.isSetRcvSettleMode()) {
        rcvSettleMode = data.getRcvSettleMode();
    }

    endpointPolicy = new CAMQPEndpointPolicy(maxMessageSize, sndSettleMode, rcvSettleMode, endpointPolicy);

    if (data.isSetProperties()) {
        endpointPolicy.getCustomProperties().putAll(data.getProperties());
    }

    CAMQPControlAttach responseData = new CAMQPControlAttach();
    responseData.setHandle(linkHandle);
    responseData.setName(linkName);
    responseData.setRole(getRole() == LinkRole.LinkReceiver);

    if (data.getSource() != null) {
        CAMQPDefinitionSource inSource = (CAMQPDefinitionSource) data.getSource();
        sourceAddress = (String) inSource.getAddress();

        if (inSource.isSetDistributionMode()) {
            String distMode = inSource.getDistributionMode();
            if (StringUtils.equalsIgnoreCase(distMode, CAMQPConstants.STD_DIST_MODE_COPY)) {
                endpointPolicy.setEndpointType(EndpointType.TOPIC);
                endpointPolicy.setLinkCreditPolicy(
                        ReceiverLinkCreditPolicy.CREDIT_STEADY_STATE_DRIVEN_BY_TARGET_MESSAGE_PROCESSING);
            }
        }
    }

    if (data.getTarget() != null) {
        CAMQPDefinitionTarget inTarget = (CAMQPDefinitionTarget) data.getTarget();
        targetAddress = (String) inTarget.getAddress();
    }

    CAMQPDefinitionSource source = new CAMQPDefinitionSource();
    source.setAddress(sourceAddress);
    responseData.setSource(source);

    CAMQPDefinitionTarget target = new CAMQPDefinitionTarget();
    target.setAddress(targetAddress);
    responseData.setTarget(target);

    source.setDynamic(false);
    responseData.setInitialDeliveryCount(deliveryCount);
    responseData.setMaxMessageSize(BigInteger.valueOf(CAMQPLinkConstants.DEFAULT_MAX_MESSAGE_SIZE));

    linkStateActor.sendAttach(responseData);
}

From source file:com.udojava.evalex.Expression.java

/**
 * Creates a new expression instance from an expression string with a given
 * default match context./*from   ww  w.j  a  va  2s .  c  o m*/
 *
 * @param expression The expression. E.g. <code>"2.4*sin(3)/(2-4)"</code> or
 *                   <code>"sin(y)>0 & max(z, 3)>3"</code>
 */
public Expression(String expression, LinkedList<String> hist, Variables vars) {
    this.history = hist;
    this.expression = expression;

    mainVars = vars;

    addOperator(new Operator("+", 20, true, "Addition") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.ARRAY) {
                MyComplex vo = new MyComplex(v1.list);
                vo.list.add(v2);
                return vo;
            }
            return v1.add(v2);
        }
    });

    addOperator(new Operator("-", 20, true, "Subtraction") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.ARRAY) {
                MyComplex vo = new MyComplex(v1.list);
                vo.list.removeIf(o -> o.equals(v2));
                return vo;
            }
            return v1.subtract(v2);
        }
    });
    addOperator(new Operator("*", 30, true, "Real number multiplication") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            return v1.multiply(v2);
        }
    });
    addOperator(new Operator("/", 30, true, "Real number division") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            return v1.divide(v2);
        }
    });
    addOperator(new Operator("%", 30, true, "Remainder of integer division") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            double r = v1.real % v2.real;
            return new MyComplex(r);
        }
    });
    addOperator(
            new Operator("^", 40, false, "Exponentation. See: https://en.wikipedia.org/wiki/Exponentiation") {
                @Override
                public MyComplex eval(MyComplex v1, MyComplex v2) {
                    return v1.pow(v2);
                }
            });
    addOperator(new Operator("&&", 4, false, "Logical AND. Evaluates to 1 if both operands are not 0") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            boolean b1 = (v1.real == 0.0 && v2.real == 0.0);
            return new MyComplex(b1 ? 1 : 0);
        }
    });

    addOperator(new Operator("||", 2, false, "Logical OR. Evaluates to 0 if both operands are 0") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            boolean b1 = (v1.real == 0.0 && v2.real == 0.0);
            return new MyComplex(b1 ? 0 : 1);
        }
    });

    addOperator(new Operator(">", 10, false,
            "Greater than. See: See: https://en.wikipedia.org/wiki/Inequality_(mathematics)") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) {
                return new MyComplex(v1.real > v2.real ? 1 : 0);
            } else {
                return new MyComplex(v1.abs() > v2.abs() ? 1 : 0);
            }
        }
    });

    addOperator(new Operator(">=", 10, false, "Greater or equal") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) {
                return new MyComplex(v1.real >= v2.real ? 1 : 0);
            } else {
                return new MyComplex(v1.abs() >= v2.abs() ? 1 : 0);
            }
        }
    });

    addOperator(new Operator("<", 10, false,
            "Less than. See: https://en.wikipedia.org/wiki/Inequality_(mathematics)") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) {
                return new MyComplex(v1.real < v2.real ? 1 : 0);
            } else {
                return new MyComplex(v1.abs() < v2.abs() ? 1 : 0);
            }
        }
    });

    addOperator(new Operator("<=", 10, false, "less or equal") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) {
                return new MyComplex(v1.real <= v2.real ? 1 : 0);
            } else {
                return new MyComplex(v1.abs() <= v2.abs() ? 1 : 0);
            }
        }
    });

    addOperator(new Operator("->", 7, false, "Set variable v to new value ") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1 instanceof PitDecimal) {
                PitDecimal target = (PitDecimal) v1;
                String s = target.getVarToken();
                setVariable(s, v2);
                return v2;
            }
            throw new ExpressionException("LHS not variable");
        }
    });

    addOperator(new Operator("=", 7, false, "Equality") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) {
                return new MyComplex(v1.real == v2.real ? 1 : 0);
            } else {
                return new MyComplex(v1.abs() == v2.abs() ? 1 : 0);
            }
        }
    });

    addOperator(new Operator("!=", 7, false,
            "Inequality. See: https://en.wikipedia.org/wiki/Inequality_(mathematics)") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) {
                return new MyComplex(v1.real != v2.real ? 1 : 0);
            } else {
                return new MyComplex(v1.abs() != v2.abs() ? 1 : 0);
            }
        }
    });
    addOperator(
            new Operator("or", 7, false, "Bitwise OR. See: https://en.wikipedia.org/wiki/Logical_disjunction") {
                @Override
                public MyComplex eval(MyComplex v1, MyComplex v2) {
                    return new MyComplex((long) v1.real | (long) v2.real);
                }
            });
    addOperator(new Operator("and", 7, false,
            "Bitwise AND. See: https://en.wikipedia.org/wiki/Logical_conjunction") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            return new MyComplex((long) v1.real & (long) v2.real);
        }
    });
    addOperator(new Operator("xor", 7, false, "Bitwise XOR, See: https://en.wikipedia.org/wiki/Exclusive_or") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            return new MyComplex((long) v1.real ^ (long) v2.real);
        }
    });

    addOperator(new Operator("!", 50, true, "Factorial. See https://en.wikipedia.org/wiki/Factorial") {
        public BigInteger factorial(long n) {
            BigInteger factorial = BigInteger.ONE;
            for (long i = 1; i <= n; i++) {
                factorial = factorial.multiply(BigInteger.valueOf(i));
            }
            return factorial;
        }

        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            BigInteger fact = factorial((long) v1.real);
            return new MyComplex(fact, BigInteger.ZERO);
        }
    });

    addOperator(new Operator("~", 8, false, "Bitwise negation") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            BigInteger bi = v2.toBigIntegerReal();
            int c = bi.bitLength();
            if (c == 0) {
                return new MyComplex(1);
            }
            for (int s = 0; s < c; s++) {
                bi = bi.flipBit(s);
            }
            return new MyComplex(bi);
        }
    });

    addOperator(new Operator("shl", 8, false, "Left Bit shift") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            return new MyComplex((long) v1.real << (long) v2.real);
        }
    });

    addOperator(new Operator("shr", 8, false, "Right bit shift") {
        @Override
        public MyComplex eval(MyComplex v1, MyComplex v2) {
            return new MyComplex((long) v1.real >>> (long) v2.real);
        }
    });

    addFunction(new Function("NOT", 1, "evaluates to 0 if argument != 0") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            boolean zero = parameters.get(0).abs() == 0;
            return new MyComplex(zero ? 1 : 0);
        }
    });

    addFunction(new Function("RND", 2, "Give random number in the range between first and second argument") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double low = parameters.get(0).real;
            double high = parameters.get(1).real;
            return new MyComplex(low + Math.random() * (high - low));
        }
    });

    MersenneTwister mers = new MersenneTwister(System.nanoTime());

    addFunction(new Function("MRS", 0, "Mersenne twister random generator") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return new MyComplex(mers.nextDouble());
        }
    });

    addFunction(new Function("BIN", 2, "Binomial Coefficient 'n choose k'") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            int n = (int) parameters.get(0).real;
            int k = (int) parameters.get(1).real;
            double d = CombinatoricsUtils.binomialCoefficientDouble(n, k);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("STIR", 2,
            "Stirling number of 2nd kind: http://mathworld.wolfram.com/StirlingNumberoftheSecondKind.html") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            int n = (int) parameters.get(0).real;
            int k = (int) parameters.get(1).real;
            double d = CombinatoricsUtils.stirlingS2(n, k);
            return new MyComplex(d);
        }
    });

    addFunction(new Function("SIN", 1, "Sine function") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).sin();
        }
    });
    addFunction(new Function("COS", 1, "Cosine function") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).cos();
        }
    });
    addFunction(new Function("TAN", 1, "Tangent") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).tan();
        }
    });
    addFunction(new Function("ASIN", 1, "Reverse Sine") { // added by av
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).asin();
        }
    });
    addFunction(new Function("ACOS", 1, "Reverse Cosine") { // added by av
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).acos();
        }
    });
    addFunction(new Function("ATAN", 1, "Reverse Tangent") { // added by av
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).atan();
        }
    });
    addFunction(new Function("SINH", 1, "Hyperbolic Sine") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).sinh();
        }
    });
    addFunction(new Function("COSH", 1, "Hyperbolic Cosine") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).cosh();
        }
    });
    addFunction(new Function("TANH", 1, "Hyperbolic Tangent") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).tanh();
        }
    });
    addFunction(new Function("RAD", 1, "Transform degree to radian") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double d = Math.toRadians(parameters.get(0).real);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("DEG", 1, "Transform radian to degree") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double d = Math.toDegrees(parameters.get(0).real);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("MAX", -1, "Find the biggest value in a list") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            MyComplex save = new MyComplex(Double.MIN_VALUE);
            if (parameters.size() == 0) {
                throw new ExpressionException("MAX requires at least one parameter");
            }
            //                if (parameters.get(0).type == ValueType.ARRAY)
            //                    parameters = parameters.get(0).list;
            if (parameters.get(0).type == ValueType.COMPLEX) {
                for (MyComplex parameter : parameters) {
                    if (parameter.abs() > save.abs()) {
                        save = parameter;
                    }
                }
                save.type = ValueType.COMPLEX;
            } else {
                for (MyComplex parameter : parameters) {
                    if (parameter.real > save.real) {
                        save = parameter;
                    }
                }
                save.type = ValueType.REAL;
            }
            return save;
        }
    });
    ///////////////////////////////////////////////////////
    addFunction(new Function("IF", 3, "Conditional: give param3 if param1 is 0, otherwise param2") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.get(0).real == 0.0) {
                return parameters.get(2);
            }
            return parameters.get(1);
        }
    });

    addFunction(new Function("PERC", 2, "Get param1 percent of param2") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).divide(new MyComplex(100)).multiply(parameters.get(1));
        }
    });

    addFunction(new Function("PER", 2, "How many percent is param1 of param2") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return parameters.get(0).multiply(new MyComplex(100)).divide(parameters.get(1));
        }
    });

    addFunction(new Function("H", 1, "Evaluate _history element") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            int i = (int) parameters.get(0).real;
            Expression ex = new Expression(history.get(i), history, mainVars);
            return ex.eval();
        }
    });

    addFunction(new Function("MERS", 1, "Calculate Mersenne Number") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            MyComplex p = parameters.get(0);
            return new MyComplex(2).pow(p).subtract(new MyComplex(1));
        }
    });

    addFunction(new Function("GCD", 2, "Find greatest common divisor of 2 values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double a = parameters.get(0).real;
            double b = parameters.get(1).real;
            long r = ArithmeticUtils.gcd((long) a, (long) b);
            return new MyComplex(r);
        }
    });
    addFunction(new Function("LCM", 2, "Find least common multiple of 2 values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double a = parameters.get(0).real;
            double b = parameters.get(1).real;
            long r = ArithmeticUtils.lcm((long) a, (long) b);
            return new MyComplex(r);
        }
    });
    addFunction(new Function("AMEAN", -1, "Arithmetic mean of a set of values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.size() == 0) {
                throw new ExpressionException("MEAN requires at least one parameter");
            }
            Mean m = new Mean();
            double[] d = MyComplex.getRealArray(parameters);
            double d2 = m.evaluate(d);
            return new MyComplex(d2);
        }
    });
    //        addFunction(new Function("BYT", -1,
    //                "Value from sequence of bytes")
    //        {
    //            @Override
    //            public MyComplex eval (List<MyComplex> parameters)
    //            {
    //                if (parameters.size() == 0)
    //                {
    //                    return MyComplex.ZERO;
    //                }
    //                BigInteger res = BigInteger.ZERO;
    //                for (MyComplex parameter : parameters)
    //                {
    //                    if (parameter.intValue() < 0 || parameter.intValue() > 255)
    //                    {
    //                        throw new ExpressionException("not a byte value");
    //                    }
    //                    res = res.shiftLeft(8);
    //                    res = res.or(parameter.toBigInteger());
    //                }
    //                return new MyComplex(res, BigInteger.ZERO);
    //            }
    //        });
    addFunction(new Function("SEQ", 3, "Generate Sequence p1=start, p2=step, p3=count") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double start = parameters.get(0).real;
            ArrayList<MyComplex> arr = new ArrayList<>();
            for (int s = 0; s < (int) (parameters.get(2).real); s++) {
                arr.add(new MyComplex(start));
                start += parameters.get(1).real;
            }
            return new MyComplex(arr);
        }
    });

    addFunction(new Function("PROD", -1, "Product of real values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            Product p = new Product();
            double[] d = MyComplex.getRealArray(parameters);
            return new MyComplex(p.evaluate(d));
        }
    });

    addFunction(new Function("SUM", -1, "Sum of values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            Sum p = new Sum();
            double[] d = MyComplex.getRealArray(parameters);
            return new MyComplex(p.evaluate(d));
        }
    });

    addFunction(new Function("ANG", 1, "Angle phi of complex number in radians") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double b = parameters.get(0).angle();
            return new MyComplex(b);
        }
    });

    addFunction(new Function("IM", 1, "Get imaginary part") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return new MyComplex(parameters.get(0).imaginary);
        }
    });

    addFunction(new Function("RE", 1, "Get real part") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return new MyComplex(parameters.get(0).real);
        }
    });

    addFunction(new Function("POL", 2, "Make complex number from polar coords. angle is first arg") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double angle = parameters.get(0).real;
            double len = parameters.get(1).real;
            Complex c = ComplexUtils.polar2Complex(len, angle);
            return new MyComplex(c);
        }
    });

    addFunction(new Function("GMEAN", -1, "Geometric mean of a set of values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.size() == 0) {
                throw new ExpressionException("MEAN requires at least one parameter");
            }
            GeometricMean m = new GeometricMean();
            double[] d = MyComplex.getRealArray(parameters);
            double d2 = m.evaluate(d);
            return new MyComplex(d2);
        }
    });

    addFunction(new Function("HMEAN", -1, "Harmonic mean of a set of values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.size() == 0) {
                throw new ExpressionException("MEAN requires at least one parameter");
            }
            MyComplex res = new MyComplex(0);
            int num = 0;
            for (MyComplex parameter : parameters) {
                res = res.add(new MyComplex(1).divide(parameter));
                num++;
            }
            res = new MyComplex(res.abs());
            return new MyComplex(num).divide(res);
        }
    });

    addFunction(new Function("VAR", -1, "Variance of a set of values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.size() == 0) {
                throw new ExpressionException("MEAN requires at least one parameter");
            }
            double[] arr = new double[parameters.size()];
            for (int s = 0; s < parameters.size(); s++) {
                arr[s] = parameters.get(s).real;
            }
            return new MyComplex(variance(arr));
        }
    });

    addFunction(new Function("NPR", 1, "Next prime number greater or equal the argument") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return new MyComplex(nextPrime((int) parameters.get(0).real));
        }
    });

    addFunction(new Function("NSWP", 1, "Swap nibbles") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            BigInteger bi = parameters.get(0).toBigIntegerReal();
            String s = bi.toString(16);
            s = new StringBuilder(s).reverse().toString();
            return new MyComplex(new BigInteger(s, 16), BigInteger.ZERO);
        }
    });

    addFunction(new Function("BSWP", 1, "Swap bytes") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            BigInteger bi = parameters.get(0).toBigIntegerReal();
            String s = bi.toString(16);
            while (s.length() % 4 != 0) {
                s = s + "0";
            }
            if (bi.intValue() < 256) {
                s = "00" + s;
            }
            s = Misc.reverseHex(s);
            return new MyComplex(new BigInteger(s, 16), BigInteger.ZERO);
        }
    });

    addFunction(new Function("PYT", 2,
            "Pythagoras's result = sqrt(param1^2+param2^2) https://en.wikipedia.org/wiki/Pythagorean_theorem") {
        @Override
        public MyComplex eval(List<MyComplex> par) {
            double a = par.get(0).real;
            double b = par.get(1).real;
            return new MyComplex(Math.sqrt(a * a + b * b));
        }
    });

    addFunction(new Function("FIB", 1, "Fibonacci number") {
        // --Commented out by Inspection (2/19/2017 7:46 PM):private final Operator exp = operators.get("^");

        @Override
        public MyComplex eval(List<MyComplex> par) {
            return Misc.iterativeFibonacci((int) par.get(0).real);
        }
    });

    ///////////////////////////////////////////////

    addFunction(new Function("MIN", -1, "Find the smallest in a list of values") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            MyComplex save = new MyComplex(Double.MAX_VALUE);
            if (parameters.size() == 0) {
                throw new ExpressionException("MAX requires at least one parameter");
            }
            if (parameters.get(0).type == ValueType.COMPLEX) {
                for (MyComplex parameter : parameters) {
                    if (parameter.abs() < save.abs()) {
                        save = parameter;
                    }
                }
                save.type = ValueType.COMPLEX;
            } else {
                for (MyComplex parameter : parameters) {
                    if (parameter.real < save.real) {
                        save = parameter;
                    }
                }
                save.type = ValueType.REAL;
            }
            return save;
        }
    });
    addFunction(new Function("ABS", 1, "Get absolute value of a number") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return new MyComplex(parameters.get(0).abs());
        }
    });
    addFunction(new Function("LN", 1, "Logarithm base e of the argument") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double d = Math.log(parameters.get(0).real);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("LOG", 1, "Logarithm base 10 of the argument") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double d = Math.log10(parameters.get(0).real);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("FLOOR", 1, "Rounds DOWN to nearest Integer") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double d = Math.floor(parameters.get(0).real);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("CEIL", 1, "Rounds UP to nearest Integer") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double d = Math.ceil(parameters.get(0).real);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("ROU", 1, "Rounds to nearest Integer") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            int d = (int) (parameters.get(0).real + 0.5);
            return new MyComplex(d);
        }
    });
    addFunction(new Function("SQRT", 1, "Square root") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            MyComplex p = parameters.get(0);
            if (p.type == ValueType.REAL) {
                return new MyComplex(Math.sqrt(p.real));
            }
            return p.sqrt();
        }
    });
    addFunction(new Function("ARR", -1, "Create array") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            return new MyComplex(parameters);
        }
    });
    addFunction(new Function("POLY", -1, "Treat array as Polynom") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            double[] d = MyComplex.getRealArray(parameters);
            PolynomialFunction p = new PolynomialFunction(d);
            return new MyComplex(p);
        }
    });
    addFunction(new Function("DRVE", -1, "Make derivative of polynomial") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            PolynomialFunction p;
            if (parameters.get(0).isPoly()) {
                p = new PolynomialFunction(parameters.get(0).getRealArray());
            } else {
                double[] d = MyComplex.getRealArray(parameters);
                p = new PolynomialFunction(d);
            }
            return new MyComplex(p.polynomialDerivative());
        }
    });
    addFunction(new Function("ADRVE", -1, "Make antiderivative of polynomial. Constant is always zero") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            PolynomialFunction p;
            if (parameters.get(0).isPoly()) {
                p = new PolynomialFunction(parameters.get(0).getRealArray());
            } else {
                double[] d = MyComplex.getRealArray(parameters);
                p = new PolynomialFunction(d);
            }
            return new MyComplex(Misc.antiDerive(p));
        }
    });

    addFunction(new Function("PVAL", 2, "Compute value of polynom for the given argument.") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.get(0).isPoly()) {
                PolynomialFunction p = new PolynomialFunction(parameters.get(0).getRealArray());
                double v = p.value(parameters.get(1).real);
                return new MyComplex(v);
            }
            throw new ExpressionException("first arg must be polynomial");
        }
    });

    addFunction(new Function("INTGR", 3, "Numerical integration") {
        @Override
        public MyComplex eval(List<MyComplex> parameters) {
            if (parameters.get(0).isPoly()) {
                PolynomialFunction p = new PolynomialFunction(parameters.get(0).getRealArray());
                double start = parameters.get(1).real;
                double end = parameters.get(2).real;
                SimpsonIntegrator si = new SimpsonIntegrator();
                double d = si.integrate(1000, p, start, end);
                return new MyComplex(d);
            }
            throw new ExpressionException("first arg must be polynomial");
        }
    });

}