data.Types Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-timeseries Show documentation
Show all versions of java-timeseries Show documentation
Time Series Analysis in Java
The newest version!
/*
* Copyright (c) 2016 Jacob Rachiele
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software without restriction
* including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished to
* do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Contributors:
*
* Jacob Rachiele
*/
package data;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
/**
* A class of static methods dealing with conversions between different data types.
*
* @author Jacob Rachiele
* Date: Dec 09 2016
*/
final class Types {
private Types() {
}
/**
* Test if the given string is representable as a double.
*
* @param pi the string to test.
* @return true if the string can be represented as a double and false otherwise.
*/
static boolean isDouble(String pi) {
final String Digits = "(\\p{Digit}+)";
final String HexDigits = "(\\p{XDigit}+)";
// an exponent is 'e' or 'E' followed by an optionally
// signed decimal integer.
final String Exp = "[eE][+-]?" + Digits;
final String fpRegex = "[\\x00-\\x20]*" + // Optional leading "whitespace"
"[+-]?(" + // Optional sign character
"NaN|" + // "NaN" string
"Infinity|" + // "Infinity" string
// A decimal floating-point string representing a finite positive
// number without a leading sign has at most five basic pieces:
// Digits . Digits ExponentPart FloatTypeSuffix
//
// Since this method allows integer-only strings as input
// in addition to strings of floating-point literals, the
// two sub-patterns below are simplifications of the grammar
// productions from section 3.10.2 of
// The Java Language Specification.
// Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
"(((" + Digits + "(\\.)?(" + Digits + "?)(" + Exp + ")?)|" +
// . Digits ExponentPart_opt FloatTypeSuffix_opt
"(\\.(" + Digits + ")(" + Exp + ")?)|" +
// Hexadecimal strings
"((" +
// 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
"(0[xX]" + HexDigits + "(\\.)?)|" +
// 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
"(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +
")[pP][+-]?" + Digits + "))" + "[fFdD]?))" +
"[\\x00-\\x20]*";// Optional trailing "whitespace"
return Pattern.matches(fpRegex, pi);
}
/**
* Convert the given list of strings to a list of doubles. This method returns the result in a new List.
*
* @param strings the list of strings to convert.
* @return the given list of strings converted to a list of doubles.
*/
static List toDoubleList(List strings) {
List doubles = new ArrayList<>(strings.size());
for (String s : strings) {
doubles.add(Double.valueOf(s));
}
return doubles;
}
/**
* Convert the given list of strings to an array of doubles. This method returns the result in a new array.
*
* @param strings the list of strings to convert.
* @return the given list of strings converted to an array of doubles.
*/
static Double[] toDoubleArray(List strings) {
Double[] doubles = new Double[strings.size()];
for (int i = 0; i < doubles.length; i++) {
doubles[i] = Double.valueOf(strings.get(i));
}
return doubles;
}
/**
* Convert the given list of strings to an array of strings. This method returns the result in a new array.
*
* @param strings the list of strings to convert to an array.
* @return the given list of strings converted to an array of strings.
*/
static String[] toStringArray(List strings) {
String[] stringArray = new String[strings.size()];
for (int i = 0; i < stringArray.length; i++) {
stringArray[i] = strings.get(i);
}
return stringArray;
}
static boolean isLocalDateTime(final String s) {
try {
LocalDateTime.parse(s);
} catch (DateTimeParseException e) {
return false;
}
return true;
}
// Shouldn't use exceptions for control flow, but parsing date-times is absurdly difficult to get right,
// so using the fact that the OffsetDateTime parse method has already done it. Downside is that this
// way of doing it will cause a performance hit.
static boolean isOffsetDateTime(final String s) {
try {
OffsetDateTime.parse(s);
} catch (DateTimeParseException e) {
return false;
}
return true;
}
/**
* Convert the given list of strings to a list of OffsetDateTimes. This method returns the result in a new List.
*
* @param strings the list of strings to convert.
* @return the given list of strings converted to a list of OffsetDateTimes.
*/
static List toOffsetDateTimeList(List strings) {
List dateTimes = new ArrayList<>(strings.size());
for (String s : strings) {
dateTimes.add(OffsetDateTime.parse(s));
}
return dateTimes;
}
/**
* Convert the given list of strings to an array of OffsetDateTimes. This method returns the result in a new array.
*
* @param strings the list of strings to convert.
* @return the given list of strings converted to an array of OffsetDateTimes.
*/
static OffsetDateTime[] toOffsetDateTimeArray(List strings) {
OffsetDateTime[] dateTimes = new OffsetDateTime[strings.size()];
for (int i = 0; i < dateTimes.length; i++) {
dateTimes[i] = OffsetDateTime.parse(strings.get(i));
}
return dateTimes;
}
static List toLocalDateTimeList(List strings) {
List dateTimes = new ArrayList<>(strings.size());
for (String s : strings) {
dateTimes.add(LocalDateTime.parse(s));
}
return dateTimes;
}
static LocalDateTime[] toLocalDateTimeArray(List strings) {
LocalDateTime[] dateTimes = new LocalDateTime[strings.size()];
for (int i = 0; i < dateTimes.length; i++) {
dateTimes[i] = LocalDateTime.parse(strings.get(i));
}
return dateTimes;
}
static List toBooleanList(List strings) {
List booleans = new ArrayList<>(strings.size());
for (String s : strings) {
booleans.add(Boolean.parseBoolean(s));
}
return booleans;
}
static Boolean[] toBooleanArray(List strings) {
Boolean[] booleans = new Boolean[strings.size()];
for (int i = 0; i < booleans.length; i++) {
booleans[i] = Boolean.parseBoolean(strings.get(i));
}
return booleans;
}
}