You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
912 lines
26 KiB
Java
912 lines
26 KiB
Java
/*
|
|
* CODE LICENSE =====================
|
|
* Copyright (c) 2015, Apocalypse Laboratories
|
|
* 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 copyright holder nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* 4. You adhere to the Media License detailed below. If you do not, this license
|
|
* is automatically revoked and you must purge all copies of the software you
|
|
* possess, in source or binary form.
|
|
*
|
|
* 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.
|
|
*
|
|
* MEDIA LICENSE ====================
|
|
* All images and other graphical files (the "graphics") included with this
|
|
* software are copyright (c) 2015 Apocalypse Laboratories. You may not distribute
|
|
* the graphics or any program, source code repository, or other digital storage
|
|
* media containing them without written permission from Apocalypse Laboratories.
|
|
* This ban on distribution only applies to publicly available systems.
|
|
* A password-protected network file share, USB drive, or other storage scheme that
|
|
* cannot be easily accessed by the public is generally allowed. If in doubt,
|
|
* contact Apocalypse Laboratories. If Apocalypse Laboratories allows or denies
|
|
* you permission, that decision is considered final and binding.
|
|
*/
|
|
package net.apocalypselabs.symat;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import static java.lang.Math.*;
|
|
import java.lang.reflect.Array;
|
|
import java.math.BigInteger;
|
|
import java.net.URL;
|
|
import java.security.SecureRandom;
|
|
import java.util.Arrays;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.NoSuchElementException;
|
|
import java.util.Set;
|
|
import javax.swing.JOptionPane;
|
|
import static net.apocalypselabs.symat.Main.API_URL;
|
|
import org.matheclipse.core.eval.EvalUtilities;
|
|
import org.matheclipse.core.interfaces.IExpr;
|
|
import org.matheclipse.parser.client.math.MathException;
|
|
|
|
/**
|
|
* These functions are accessible from JavaScript.
|
|
*
|
|
* There are a lot of aliases in here too.
|
|
*
|
|
* @author Skylar
|
|
*/
|
|
public class Functions {
|
|
|
|
public static final HashMap<String, Object> GLOBALS = new HashMap<>();
|
|
|
|
private final EvalUtilities util = new EvalUtilities(true, true);
|
|
Graph graphwin = new Graph(true);
|
|
|
|
private String lang = "py";
|
|
|
|
private final SecureRandom rng = new SecureRandom();
|
|
|
|
/*
|
|
Useful interactions
|
|
*/
|
|
/**
|
|
* Display a message dialog box.
|
|
*
|
|
* @param message The message to give.
|
|
*/
|
|
public void notify(Object message) {
|
|
JOptionPane.showInternalMessageDialog(Main.mainPane, message.toString());
|
|
}
|
|
|
|
/**
|
|
* Display an input dialog box with a text field.
|
|
*
|
|
* @param question Text to label dialog
|
|
* @return The inputted text
|
|
*/
|
|
public String ask(String question) {
|
|
return JOptionPane.showInternalInputDialog(Main.mainPane, question);
|
|
}
|
|
|
|
/**
|
|
* Quit SyMAT.
|
|
*/
|
|
public void quitApplication() {
|
|
System.exit(0);
|
|
}
|
|
|
|
/*
|
|
Math commands
|
|
*/
|
|
/**
|
|
* Find the factorial (n!) of a number.
|
|
*
|
|
* @param n positive integer
|
|
* @return n! as String
|
|
* @throws net.apocalypselabs.symat.BadInputException
|
|
*/
|
|
public String factorial(long n) throws BadInputException {
|
|
if (n <= 0) {
|
|
throw new BadInputException("Input must be greater than zero!");
|
|
}
|
|
|
|
BigInteger inc = new BigInteger("1");
|
|
BigInteger fact = new BigInteger("1");
|
|
|
|
for (long c = 1; c <= n; c++) {
|
|
fact = fact.multiply(inc);
|
|
inc = inc.add(BigInteger.ONE);
|
|
}
|
|
return fact.toString();
|
|
}
|
|
|
|
/**
|
|
* Differentiate the function with respect to idv.
|
|
*
|
|
* @param function Function
|
|
* @param idv independent variable
|
|
* @return Differentiated function
|
|
*/
|
|
public String diff(String function, String idv) {
|
|
return util.evaluate("diff(" + function + "," + idv + ")").toString();
|
|
}
|
|
|
|
/**
|
|
* Differentiate the function with respect to x.
|
|
*
|
|
* @param function Function
|
|
* @return Differentiated function
|
|
*/
|
|
public String diff(String function) {
|
|
// Assume "x" as var
|
|
return diff(function, "x");
|
|
}
|
|
|
|
@Deprecated
|
|
public String D(String function, String idv) {
|
|
return diff(function, idv);
|
|
}
|
|
|
|
/**
|
|
* Integrate the function with respect to idv.
|
|
*
|
|
* @param function Function
|
|
* @param idv independent variable
|
|
* @return Integrated function
|
|
*/
|
|
public String integrate(String function, String idv) {
|
|
return util.evaluate("integrate(" + function + "," + idv + ")").toString();
|
|
}
|
|
|
|
/**
|
|
* Integrate the function with respect to x.
|
|
*
|
|
* @param function Function
|
|
* @return Integrated function
|
|
*/
|
|
public String integrate(String function) {
|
|
return integrate(function, "x");
|
|
}
|
|
|
|
public String factor(String function) {
|
|
return sym("Factor(" + function + ")");
|
|
}
|
|
|
|
/**
|
|
* Simplify the given expression.
|
|
*
|
|
* @param expr expression
|
|
* @return simplified expression
|
|
*/
|
|
public String simplify(String expr) {
|
|
return sym("Simplify(" + expr + ")");
|
|
}
|
|
|
|
public Object vpa(String expr) {
|
|
IExpr ans = util.evaluate("N(" + expr + ")");
|
|
if (ans.isNumber()) {
|
|
return Double.parseDouble(ans.toString());
|
|
}
|
|
return ans.toString();
|
|
}
|
|
|
|
/**
|
|
* Multiplies the given numbers together.
|
|
*
|
|
* @param a numbers. Calculates first * second * third, etc.
|
|
* @return The product of the numbers or the value of input if there is only
|
|
* one input.
|
|
*/
|
|
public double times(double... a) {
|
|
double ans = 0;
|
|
for (int i = 0; i < a.length; i++) {
|
|
if (i == 0) {
|
|
ans = a[i];
|
|
} else {
|
|
ans *= a[i];
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
/**
|
|
* Divide the given numbers.
|
|
*
|
|
* @param a numbers. Calculates (first / second) / third, etc.
|
|
* @return The quotient of the numbers or the value of input if there is
|
|
* only one input.
|
|
*/
|
|
public double divide(double... a) {
|
|
double ans = 0;
|
|
for (int i = 0; i < a.length; i++) {
|
|
if (i == 0) {
|
|
ans = a[i];
|
|
} else {
|
|
ans /= a[i];
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
/**
|
|
* Divide the first number by the second and return the remainder.
|
|
*
|
|
* @param a numbers. Calculates (first mod second) mod third, etc.
|
|
* @return The modulus of the numbers or the value of input if there is only
|
|
* one input.
|
|
*/
|
|
public double mod(double... a) {
|
|
double ans = 0;
|
|
for (int i = 0; i < a.length; i++) {
|
|
if (i == 0) {
|
|
ans = a[i];
|
|
} else {
|
|
ans %= a[i];
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
/**
|
|
* Add the given numbers together.
|
|
*
|
|
* @param a numbers. Calculates first + second + third, etc.
|
|
* @return The sum of the numbers or the value of input if there is only one
|
|
* input.
|
|
*/
|
|
public double add(double... a) {
|
|
double ans = 0;
|
|
for (double d : a) {
|
|
ans += d;
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
/**
|
|
* Subtract the given numbers.
|
|
*
|
|
* @param a numbers. Calculates (first - second) - third, etc.
|
|
* @return The difference of the numbers or the value of input if there is
|
|
* only one input.
|
|
*/
|
|
public double subtract(double... a) {
|
|
double ans = 0;
|
|
for (int i = 0; i < a.length; i++) {
|
|
if (i == 0) {
|
|
ans = a[i];
|
|
} else {
|
|
ans -= a[i];
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
public double[][] $minvert(double a[][]) {
|
|
int n = a.length;
|
|
double x[][] = new double[n][n];
|
|
double b[][] = new double[n][n];
|
|
int index[] = new int[n];
|
|
for (int i = 0; i < n; ++i) {
|
|
b[i][i] = 1;
|
|
}
|
|
// Transform the matrix into an upper triangle
|
|
gaussian(a, index);
|
|
// Update the matrix b[i][j] with the ratios stored
|
|
for (int i = 0; i < n - 1; ++i) {
|
|
for (int j = i + 1; j < n; ++j) {
|
|
for (int k = 0; k < n; ++k) {
|
|
b[index[j]][k]
|
|
-= a[index[j]][i] * b[index[i]][k];
|
|
}
|
|
}
|
|
}
|
|
// Perform backward substitutions
|
|
for (int i = 0; i < n; ++i) {
|
|
x[n - 1][i] = b[index[n - 1]][i] / a[index[n - 1]][n - 1];
|
|
for (int j = n - 2; j >= 0; --j) {
|
|
x[j][i] = b[index[j]][i];
|
|
for (int k = j + 1; k < n; ++k) {
|
|
x[j][i] -= a[index[j]][k] * x[k][i];
|
|
}
|
|
x[j][i] /= a[index[j]][j];
|
|
}
|
|
}
|
|
return x;
|
|
}
|
|
|
|
// Method to carry out the partial-pivoting Gaussian
|
|
// elimination. Here index[] stores pivoting order.
|
|
private void gaussian(double a[][], int index[]) {
|
|
int n = index.length;
|
|
double c[] = new double[n];
|
|
// Initialize the index
|
|
for (int i = 0; i < n; ++i) {
|
|
index[i] = i;
|
|
}
|
|
// Find the rescaling factors, one from each row
|
|
for (int i = 0; i < n; ++i) {
|
|
double c1 = 0;
|
|
for (int j = 0; j < n; ++j) {
|
|
double c0 = Math.abs(a[i][j]);
|
|
if (c0 > c1) {
|
|
c1 = c0;
|
|
}
|
|
}
|
|
c[i] = c1;
|
|
}
|
|
|
|
// Search the pivoting element from each column
|
|
int k = 0;
|
|
for (int j = 0; j < n - 1; ++j) {
|
|
double pi1 = 0;
|
|
for (int i = j; i < n; ++i) {
|
|
double pi0 = Math.abs(a[index[i]][j]);
|
|
pi0 /= c[index[i]];
|
|
if (pi0 > pi1) {
|
|
pi1 = pi0;
|
|
k = i;
|
|
}
|
|
}
|
|
|
|
// Interchange rows according to the pivoting order
|
|
int itmp = index[j];
|
|
index[j] = index[k];
|
|
index[k] = itmp;
|
|
for (int i = j + 1; i < n; ++i) {
|
|
double pj = a[index[i]][j] / a[index[j]][j];
|
|
// Record pivoting ratios below the diagonal
|
|
a[index[i]][j] = pj;
|
|
// Modify other elements accordingly
|
|
for (int l = j + 1; l < n; ++l) {
|
|
a[index[i]][l] -= pj * a[index[j]][l];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all prime factors of input number.
|
|
*
|
|
* @param n An integer number.
|
|
* @return Array of primes.
|
|
*
|
|
* Thanks to
|
|
* http://www.javacodegeeks.com/2014/05/how-to-find-prime-factors-of-integer-numbers-in-java-factorization.html
|
|
* and http://stackoverflow.com/a/2451219/2534036
|
|
*/
|
|
public long[] factor(long n) {
|
|
long i;
|
|
Set primes = new HashSet<>();
|
|
long copyOfInput = n;
|
|
|
|
for (i = 2; i <= copyOfInput; i++) {
|
|
if (copyOfInput % i == 0) {
|
|
primes.add(i); // prime factor
|
|
copyOfInput /= i;
|
|
i--;
|
|
}
|
|
}
|
|
long[] a = new long[primes.size()];
|
|
int j = 0;
|
|
for (Object val : primes) {
|
|
a[j++] = (long) val;
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/**
|
|
* Get all unique permutations of the given array.
|
|
*
|
|
* @param objs Array of items.
|
|
* @return Matrix
|
|
*/
|
|
public Object[] perms(Object... objs) {
|
|
Permutations<Object> perm = new Permutations<>(objs);
|
|
|
|
Set perms = new HashSet<>();
|
|
|
|
while (perm.hasNext()) {
|
|
perms.add(perm.next());
|
|
}
|
|
|
|
Object[][] a = new Object[perms.size()][objs.length];
|
|
return perms.toArray(a);
|
|
}
|
|
|
|
/**
|
|
* Get a uniform random fraction between 0.0 (inclusive) and 1.0
|
|
* (exclusive).
|
|
*
|
|
* @return random fraction
|
|
*/
|
|
public double rand() {
|
|
return rng.nextDouble();
|
|
}
|
|
|
|
/**
|
|
* Get a random boolean value.
|
|
*
|
|
* @return true or false
|
|
*/
|
|
public boolean randb() {
|
|
return rng.nextBoolean();
|
|
}
|
|
|
|
/**
|
|
* Get a uniform random integer.
|
|
*
|
|
* @param min Minimum value, inclusive
|
|
* @param max Maximum value, inclusive
|
|
* @return random integer
|
|
*/
|
|
public int rand(int min, int max) {
|
|
return rng.nextInt((max - min) + 1) + min;
|
|
}
|
|
|
|
/**
|
|
* Multiply two matrices.
|
|
*
|
|
* @param a First matrix
|
|
* @param b Second matrix
|
|
* @return The multiplied matrices
|
|
* @throws net.apocalypselabs.symat.BadInputException When the matrices are
|
|
* wrong.
|
|
*/
|
|
public double[][] $mtimes(double[][] a, double[][] b) throws BadInputException {
|
|
double[][] ans = new double[a.length][b[0].length];
|
|
double sum = 0;
|
|
int c, d, k, m = a.length, q = b[0].length, p = b.length;
|
|
|
|
if (a[0].length != b.length) {
|
|
throw new BadInputException("First matrix column count must match "
|
|
+ "second matrix row count.");
|
|
}
|
|
|
|
for (c = 0; c < m; c++) {
|
|
for (d = 0; d < q; d++) {
|
|
for (k = 0; k < p; k++) {
|
|
sum = sum + a[c][k] * b[k][d];
|
|
}
|
|
ans[c][d] = sum;
|
|
sum = 0;
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
/**
|
|
* Multiply the given matrix by itself b times.
|
|
*
|
|
* @param a Square matrix
|
|
* @param b Power ( >= 0 )
|
|
* @return The matrix result
|
|
* @throws BadInputException if the matrix is not square or power is less
|
|
* than 0
|
|
*/
|
|
public double[][] $mpower(double[][] a, int b) throws BadInputException {
|
|
if (a.length != a[0].length) {
|
|
throw new BadInputException("Matrix needs to be square.");
|
|
}
|
|
if (b < 0) {
|
|
throw new BadInputException("Power cannot be negative.");
|
|
}
|
|
|
|
double[][] ans = a;
|
|
|
|
for (int i = 0; i < b; i++) {
|
|
if (i == 0) {
|
|
ans = a;
|
|
} else {
|
|
ans = $mtimes(a, ans);
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
/**
|
|
* Convert the given number of degrees to radians.
|
|
*
|
|
* @param degrees Number in degrees
|
|
* @return Radians (degrees * (pi/180))
|
|
*/
|
|
public double rad(double degrees) {
|
|
return degrees * (PI / 180);
|
|
}
|
|
|
|
/**
|
|
* Convert the given number of radians to degrees.
|
|
*
|
|
* @param radians Number in radians
|
|
* @return Degrees (radians * (180/pi))
|
|
*/
|
|
public double deg(double radians) {
|
|
return radians * (180 / PI);
|
|
}
|
|
|
|
public String sym(String input) {
|
|
return util.evaluate(input).toString();
|
|
}
|
|
|
|
/**
|
|
* Evaluate the given text with the builtin Symja parser.
|
|
*
|
|
* @param input
|
|
* @return
|
|
*/
|
|
public String $(String input) {
|
|
return sym(input);
|
|
}
|
|
|
|
/**
|
|
* Replace all occurrences of variable with newvar in function.
|
|
*
|
|
* @param function Text input
|
|
* @param variable Text to replace
|
|
* @param newvar Text to replace with
|
|
* @return function with text replaced.
|
|
*/
|
|
public String replace(String function, String variable, String newvar) {
|
|
return function.replaceAll(variable, newvar);
|
|
}
|
|
|
|
/**
|
|
* Substitute newvar for variable in function and attempt to calculate a
|
|
* numerical answer.
|
|
* <br />Example: subs('32*x','x',2) = 64.0
|
|
*
|
|
* @param function Function
|
|
* @param variable Variable to substitute
|
|
* @param newvar Value to replace with
|
|
* @return The numerical answer or zero if there is no numerical answer.
|
|
*/
|
|
public double subs(String function, String variable, String newvar) {
|
|
return numof(function.replaceAll(variable, newvar));
|
|
}
|
|
|
|
/**
|
|
* Attempt to find numerical value of input.
|
|
*
|
|
* @param f Function
|
|
* @return answer or zero if it doesn't exist
|
|
*/
|
|
public double numof(String f) {
|
|
try {
|
|
return Double.parseDouble(util.evaluate("N(" + f + ")").toString());
|
|
} catch (MathException | NumberFormatException ex) {
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Graphing interfaces
|
|
*/
|
|
public void xlim(double xmin, double xmax) {
|
|
graphwin.setRange(xmin, xmax);
|
|
}
|
|
|
|
public void plot(String function) {
|
|
showGraph();
|
|
graphwin.graphFunction(function);
|
|
}
|
|
|
|
public void plot(double[] x, double[] y) {
|
|
graphwin.plotPoints(x, y);
|
|
}
|
|
|
|
public void plot(double[] x, double[] y, String name) {
|
|
graphwin.plotPoints(x, y, name);
|
|
}
|
|
|
|
public void plot(String function, double xmin, double xmax) {
|
|
graphwin.setRange(xmin, xmax);
|
|
plot(function);
|
|
}
|
|
|
|
public void ezplot(String f) {
|
|
plot(f);
|
|
}
|
|
|
|
public void ezplot(String function, double xmin, double xmax) {
|
|
plot(function, xmin, xmax);
|
|
}
|
|
|
|
public void graph(String f) {
|
|
plot(f);
|
|
}
|
|
|
|
public void plotname(String t) {
|
|
graphwin.setWindowTitle(t);
|
|
graphwin.setLabel(t);
|
|
}
|
|
|
|
public String plotname() {
|
|
return graphwin.getTitle();
|
|
}
|
|
|
|
public void plot() {
|
|
showGraph();
|
|
}
|
|
|
|
public void plotclr() {
|
|
graphwin.clearDraw();
|
|
}
|
|
|
|
public void clearplot() {
|
|
plotclr();
|
|
}
|
|
|
|
public void plotclear() {
|
|
plotclr();
|
|
}
|
|
|
|
public void drawdot(double x, double y) {
|
|
showGraph();
|
|
graphwin.drawDot(x, y);
|
|
}
|
|
|
|
public String readfile(String path) throws IOException {
|
|
return FileUtils.readFile(path);
|
|
}
|
|
|
|
public void savefile(String content, String path) throws IOException {
|
|
FileUtils.saveFile(content, path, false);
|
|
}
|
|
|
|
public String md5sum(String data) {
|
|
return FileUtils.MD5(data);
|
|
}
|
|
|
|
// TODO: Make globals work!
|
|
// /*
|
|
// Global variables are accessible across scripts.
|
|
// */
|
|
// /**
|
|
// * Set a global variable.
|
|
// *
|
|
// * @param name The variable name
|
|
// * @param var The variable
|
|
// */
|
|
// public static void global(String name, Object var) {
|
|
// GLOBALS.put(name, var);
|
|
// }
|
|
//
|
|
// /**
|
|
// * Get a global variable.
|
|
// *
|
|
// * @param name The variable name
|
|
// * @return The variable
|
|
// */
|
|
// public static Object global(String name) {
|
|
// Object item = GLOBALS.get(name);
|
|
// return item;
|
|
// }
|
|
//
|
|
// // Fix for Python reserved word "global"
|
|
// public static void setglobal(String name, Object var) {
|
|
// global(name, var);
|
|
// }
|
|
//
|
|
// // Fix for Python reserved word "global"
|
|
// public static void getglobal(String name) {
|
|
// global(name);
|
|
// }
|
|
//
|
|
// /**
|
|
// * Clear all the GLOBALS.
|
|
// */
|
|
// public static void clrglobals() {
|
|
// GLOBALS.clear();
|
|
// }
|
|
//
|
|
// /**
|
|
// * Check if the given global key is set.
|
|
// * @param name The key to check.
|
|
// * @return True if the key exists, else false.
|
|
// */
|
|
// public static boolean globalcontains(String name) {
|
|
// return GLOBALS.containsKey(name);
|
|
// }
|
|
|
|
/*
|
|
Other
|
|
*/
|
|
public String sysinfo() {
|
|
String info = "==Java Information==\n";
|
|
info += "Java version: " + System.getProperty("java.version");
|
|
info += "\nJava vendor: " + System.getProperty("java.vendor");
|
|
info += "\nJava home: " + System.getProperty("java.home");
|
|
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Reset the license, quit the application.
|
|
*/
|
|
public void resetlicense() {
|
|
int result = JOptionPane.showConfirmDialog(null,
|
|
"Are you sure you want to reset your license?\n"
|
|
+ "This will close SyMAT and all open files!",
|
|
"Reset license",
|
|
JOptionPane.YES_NO_CANCEL_OPTION,
|
|
JOptionPane.QUESTION_MESSAGE);
|
|
if (result == JOptionPane.YES_OPTION) {
|
|
PrefStorage.unset("license");
|
|
System.exit(0);
|
|
}
|
|
}
|
|
|
|
public String license() {
|
|
String expires = "Error";
|
|
if (PrefStorage.getSetting("licensetype").equals("demo")) {
|
|
Calendar c = Calendar.getInstance();
|
|
c.setTime(new Date());
|
|
try {
|
|
long expire = Long.parseLong(PrefStorage.getSetting("license"));
|
|
long days = (((expire - c.getTimeInMillis()) / (60 * 60 * 24)) - 999) / 1000;
|
|
if (days < 0) {
|
|
if (days == -1) {
|
|
expires = "Today";
|
|
} else {
|
|
expires = abs(days) + " days ago";
|
|
}
|
|
} else {
|
|
expires = "In " + days + " days";
|
|
}
|
|
} catch (NumberFormatException e) {
|
|
}
|
|
} else {
|
|
try {
|
|
URL url = new URL(API_URL + "expire.php?email=" + PrefStorage.getSetting("license"));
|
|
try (InputStream is = url.openStream();
|
|
BufferedReader br
|
|
= new BufferedReader(new InputStreamReader(is))) {
|
|
expires = br.readLine();
|
|
} catch (IOException ex) {
|
|
}
|
|
} catch (Exception ex) {
|
|
}
|
|
}
|
|
String lic = "==License Information==\n"
|
|
+ "License: " + PrefStorage.getSetting("license")
|
|
+ "\nType: " + PrefStorage.getSetting("licensetype")
|
|
+ "\nExpires: " + expires;
|
|
return lic;
|
|
}
|
|
|
|
/**
|
|
* Make sure the graph window shows.
|
|
*/
|
|
private void showGraph() {
|
|
graphwin.setVisible(true);
|
|
graphwin.toFront();
|
|
}
|
|
/*
|
|
Constructor.
|
|
*/
|
|
|
|
public Functions() {
|
|
Main.loadFrame(graphwin, false);
|
|
}
|
|
|
|
public void setLang(String l) {
|
|
lang = l;
|
|
|
|
}
|
|
|
|
/**
|
|
* This class finds permutations of an array.
|
|
*
|
|
* Credit to http://stackoverflow.com/a/14444037/2534036
|
|
*
|
|
* License: CC-BY-SA 3.0
|
|
*
|
|
* @param <E>
|
|
*/
|
|
class Permutations<E> implements Iterator<E[]> {
|
|
|
|
private final E[] arr;
|
|
private final int[] ind;
|
|
private boolean has_next;
|
|
|
|
public E[] output;//next() returns this array, make it public
|
|
|
|
Permutations(E[] arr) {
|
|
this.arr = arr.clone();
|
|
ind = new int[arr.length];
|
|
//convert an array of any elements into array of integers - first occurrence is used to enumerate
|
|
Map<E, Integer> hm = new HashMap<>();
|
|
for (int i = 0; i < arr.length; i++) {
|
|
Integer n = hm.get(arr[i]);
|
|
if (n == null) {
|
|
hm.put(arr[i], i);
|
|
n = i;
|
|
}
|
|
ind[i] = n;
|
|
}
|
|
Arrays.sort(ind);//start with ascending sequence of integers
|
|
|
|
//output = new E[arr.length]; <-- cannot do in Java with generics, so use reflection
|
|
output = (E[]) Array.newInstance(arr.getClass().getComponentType(), arr.length);
|
|
has_next = true;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasNext() {
|
|
return has_next;
|
|
}
|
|
|
|
/**
|
|
* Computes next permutations. Same array instance is returned every
|
|
* time!
|
|
*
|
|
* @return
|
|
*/
|
|
@Override
|
|
public E[] next() {
|
|
if (!has_next) {
|
|
throw new NoSuchElementException();
|
|
}
|
|
|
|
for (int i = 0; i < ind.length; i++) {
|
|
output[i] = arr[ind[i]];
|
|
}
|
|
|
|
//get next permutation
|
|
has_next = false;
|
|
for (int tail = ind.length - 1; tail > 0; tail--) {
|
|
if (ind[tail - 1] < ind[tail]) {//still increasing
|
|
|
|
//find last element which does not exceed ind[tail-1]
|
|
int s = ind.length - 1;
|
|
while (ind[tail - 1] >= ind[s]) {
|
|
s--;
|
|
}
|
|
|
|
swap(ind, tail - 1, s);
|
|
|
|
//reverse order of elements in the tail
|
|
for (int i = tail, j = ind.length - 1; i < j; i++, j--) {
|
|
swap(ind, i, j);
|
|
}
|
|
has_next = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
return output;
|
|
}
|
|
|
|
private void swap(int[] arr, int i, int j) {
|
|
int t = arr[i];
|
|
arr[i] = arr[j];
|
|
arr[j] = t;
|
|
}
|
|
|
|
@Override
|
|
public void remove() {
|
|
|
|
}
|
|
}
|
|
}
|