private static InterpolationTypes GetSmartType(float from, float to, InterpolationTypes type)
{
switch (type)
{
case InterpolationTypes.SmartSquared:
//Debug.LogFormat("Determining Smart type for {0} -> {1}: '{2}' -> '{3}'!", from, to, type,
// to > from ? InterpolationTypes.Squared : InterpolationTypes.InverseSquared);
return(to > from ? InterpolationTypes.Squared : InterpolationTypes.InverseSquared);
case InterpolationTypes.SmartInverseSquared:
//Debug.LogFormat("Determining Smart type for {0} -> {1}: '{2}' -> '{3}'!", from, to, type,
// to > from ? InterpolationTypes.InverseSquared : InterpolationTypes.Squared);
return(to > from ? InterpolationTypes.InverseSquared : InterpolationTypes.Squared);
case InterpolationTypes.SmartCubic:
//Debug.LogFormat("Determining Smart type for {0} -> {1}: '{2}' -> '{3}'!", from, to, type,
// to > from ? InterpolationTypes.Cubic : InterpolationTypes.InverseCubic);
return(to > from ? InterpolationTypes.Cubic : InterpolationTypes.InverseCubic);
case InterpolationTypes.SmartInverseCubic:
//Debug.LogFormat("Determining Smart type for {0} -> {1}: '{2}' -> '{3}'!", from, to, type,
// to > from ? InterpolationTypes.InverseCubic : InterpolationTypes.Cubic);
return(to > from ? InterpolationTypes.InverseCubic : InterpolationTypes.Cubic);
default:
return(type);
}
}
/// <summary>
/// Gets the appropriate interpolation method based on the InterpolationType passed in.
/// </summary>
/// <param name="interpolationType">The InterpolationTypes to get.</param>
/// <returns>The interpolation method associated with the InterpolationType, otherwise null.</returns>
private static InterpolationMethod GetInterpolationFromType(InterpolationTypes interpolationType)
{
switch (interpolationType)
{
case InterpolationTypes.Linear: return(LinearTime);
case InterpolationTypes.QuadIn: return(EaseInQuadTime);
case InterpolationTypes.QuadOut: return(EaseOutQuadTime);
case InterpolationTypes.QuadInOut: return(EaseInOutQuadTime);
case InterpolationTypes.CubicIn: return(EaseInCubicTime);
case InterpolationTypes.CubicOut: return(EaseOutCubicTime);
case InterpolationTypes.CubicInOut: return(EaseInOutCubicTime);
case InterpolationTypes.ExponentialIn: return(EaseInExponentialTime);
case InterpolationTypes.ExponentialOut: return(EaseOutExponentialTime);
case InterpolationTypes.ExponentialInOut: return(EaseInOutExponentialTime);
case InterpolationTypes.SineIn: return(EaseInSineTime);
case InterpolationTypes.SineOut: return(EaseOutSineTime);
case InterpolationTypes.SineInOut: return(EaseInOutSineTime);
default: return(null);
}
}
/// <summary>
/// Apply the given interpolation to the value t (range 0 to 1) a given number of times.
/// </summary>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <param name="repeats">The amount of times the interpolation will be applied (range 0 to 10)</param>
/// <returns>The interpolated value (range 0 to 1)</returns>
public static float ApplyLerpRepeatedly(float t, InterpolationTypes type, int repeats)
{
repeats = Mathf.Clamp(repeats, 0, 10);
for (byte i = 0; i < repeats; i++)
{
t = ApplyLerp(t, type);
}
return(t);
}
private async void ScaleMenuFlyoutItem_Click(object sender, RoutedEventArgs e)
{
AddToUndo(WriteableOutputImage.Clone());
ScaleImageDialog dialog = new ScaleImageDialog();
ContentDialogResult result = await dialog.ShowAsync();
InterpolationTypes interpolationTypes = dialog.Interpolation;
double scale = await dialog.GetScaleValue();
WriteableOutputImage = BitmapResizeHelper.Resize(WriteableOutputImage, (int)(WriteableOutputImage.PixelWidth * scale), (int)(WriteableOutputImage.PixelHeight * scale), interpolationTypes);
await UpdateOutputImage();
}
void Update()
{
if (InterpolationType != _LastInterpolationType)
{
SetupInterpolator();
_LastInterpolationType = InterpolationType;
}
if (_Interpolator != null)
{
_Interpolator.Update(Time.time);
var point = _Interpolator.GetDataPoint(Time.time - Delay);
ObjectToMove.position = point;
}
}
internal static NativeMethods.InterpolationTypes ToNativeInterpolationTypes(this InterpolationTypes interpolationTypes)
{
switch (interpolationTypes)
{
case InterpolationTypes.NearestNeighbor:
return(NativeMethods.InterpolationTypes.NearestNeighbor);
case InterpolationTypes.Bilinear:
return(NativeMethods.InterpolationTypes.Bilinear);
case InterpolationTypes.Quadratic:
return(NativeMethods.InterpolationTypes.Quadratic);
default:
throw new ArgumentOutOfRangeException(nameof(interpolationTypes), interpolationTypes, null);
}
}
public Texture2D GetTexture(int width, InterpolationTypes type = InterpolationTypes.Linear)
{
Texture2D texture = new Texture2D(width, 1);
Color[] pixelColors = new Color[width];
for (int i = 0; i < pixelColors.Length; i++)
{
float t = (float)i / (width - 1);
pixelColors[i] = Evaluate(t, type);
}
texture.SetPixels(pixelColors);
texture.Apply();
return(texture);
}
// ----------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Apply the given interpolation to the value t (range 0 to 1).
/// </summary>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <returns>The interpolated value (range 0 to 1)</returns>
public static float ApplyLerp(float t, InterpolationTypes type)
{
t = Mathf.Clamp01(t);
float i = 1f - t; // Store inverted t for inverted functions
// Calculations based on the exmaples avaliable at http://sol.gfxile.net/interpolation/
switch (type)
{
case InterpolationTypes.Linear:
return(t);
case InterpolationTypes.Smooth: // Regular smoothstep
return(t * t * (3 - 2 * t));
case InterpolationTypes.Smoother: // Based on the formula by Ken Perlin.
return(t = t * t * t * (t * (t * 6 - 15) + 10));
case InterpolationTypes.Squared:
case InterpolationTypes.SmartSquared:
return(t * t);
case InterpolationTypes.InverseSquared:
case InterpolationTypes.SmartInverseSquared:
return(1f - (i * i));
case InterpolationTypes.Cubic:
case InterpolationTypes.SmartCubic:
return(t * t * t);
case InterpolationTypes.InverseCubic:
case InterpolationTypes.SmartInverseCubic:
return(1f - (i * i * i));
case InterpolationTypes.Sin:
return(t * (Mathf.PI / 2f));
case InterpolationTypes.InverseSin:
return(1f - (i * (Mathf.PI / 2f)));
default:
Debug.LogWarningFormat("Unhandled LerpType '{0}' requested!", type);
return(t);
}
}
void Start()
{
var options = System.Enum.GetValues(typeof(InterpolationTypes)).Cast <int>();
InterpolationTypeDropDown.AddOptions(options.Select(e => ((InterpolationTypes)e).ToString()).ToList());
InterpolationTypeDropDown.value = (int)InterpolationType;
InterpolationTypeDropDown.onValueChanged.AddListener((value) => InterpolationType = (InterpolationTypes)value);
DelayInput.text = Delay.ToString();
HistoryLengthInput.text = HistoryLength.ToString();
MaxExtrapolationInput.text = MaxExtrapolation.ToString();
DelayInput.onValueChanged.AddListener((value) => Delay = float.Parse(value));
HistoryLengthInput.onValueChanged.AddListener((value) => HistoryLength = float.Parse(value));
MaxExtrapolationInput.onValueChanged.AddListener((value) => MaxExtrapolation = float.Parse(value));
SetupInterpolator();
NetworkSimulator.SetPackageListener(OnPackage);
}
void DrawSettingsBlock()
{
Rect rect = new Rect(borderSize, gradientTexHeight * 2 + borderSize, _gradientPreviewTexRect.width, _gradientPreviewTexRect.height * 2);
GUILayout.BeginArea(rect);
EditorGUI.BeginChangeCheck();
Color selectedKeyColor = (_currentlySelected == null) ? Color.white : _currentlySelected.BoundKey.Color;
Color color = EditorGUILayout.ColorField(selectedKeyColor);
if (EditorGUI.EndChangeCheck())
{
_currentlySelected.BoundKey.Color = color;
GUI.changed = true;
}
EditorGUI.BeginChangeCheck();
InterpolationTypes selectedType = (InterpolationTypes)EditorGUILayout.EnumPopup(_gradient.interpolationTypes);
if (EditorGUI.EndChangeCheck())
{
_type = selectedType;
GUI.changed = true;
}
if (GUILayout.Button("Save as PNG"))
{
Texture2D texture = _gradient.GetTexture(64, _type);
byte[] bytes = texture.EncodeToPNG();
string fileName = string.Format("Gradient{0}x{1}.png", texture.width, texture.height);
string filePath = string.Format(@"{0}/{1}/", Application.dataPath, "Textures");
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
File.WriteAllBytes(filePath + fileName, bytes);
}
GUILayout.EndArea();
}
Color Evaluate(float time, InterpolationTypes type)
{
int ti = 0;
for (int i = 0; i < ColorKeys.Count - 1; i++)
{
if ((time >= ColorKeys[i].Time) && (time <= ColorKeys[i + 1].Time))
{
ti = i;
break;
}
}
Color color = new Color();
switch (type)
{
case (InterpolationTypes.ConstantMin):
{
color = ColorKeys[ti].Color;
break;
}
case (InterpolationTypes.Linear):
{
// InverseLerp: (t - ti) / (tii - ti)
float localTime = Mathf.InverseLerp(ColorKeys[ti].Time, ColorKeys[ti + 1].Time, time);
color = Color.Lerp(ColorKeys[ti].Color, ColorKeys[ti + 1].Color, localTime);
break;
}
}
return(color);
}
public static void ResizeImage <T>(Matrix <T> src, Matrix <T> dst, InterpolationTypes interpolationTypes = InterpolationTypes.Bilinear)
where T : struct
{
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
src.ThrowIfDisposed(nameof(src));
dst.ThrowIfDisposed(nameof(dst));
var templateRows = (uint)src.TemplateRows;
var templateColumns = (uint)src.TemplateColumns;
if (templateRows != dst.TemplateRows || templateColumns != dst.TemplateColumns)
{
throw new ArgumentException();
}
var inType = src.MatrixElementType.ToNativeMatrixElementType();
var ret = NativeMethods.resize_image_matrix(inType,
src.NativePtr,
templateRows,
templateColumns,
dst.NativePtr,
interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case NativeMethods.ErrorType.MatrixElementTemplateSizeNotSupport:
throw new ArgumentException($"{nameof(src.TemplateColumns)} or {nameof(src.TemplateRows)} is not supported.");
case NativeMethods.ErrorType.MatrixElementTypeNotSupport:
throw new ArgumentException($"{src.MatrixElementType} is not supported.");
}
}
public SoftwareFCurve(RMX_ActionFCurve fcurve)
{
switch (fcurve.Type)
{
case "OBJECT": Type = FCurveTypes.Object; break;
case "BONE": Type = FCurveTypes.Bone; break;
default: Debug.ThrowError("", "Unsuported type: " + fcurve.Type); break;
}
DataPath = fcurve.DataPath;
Index = fcurve.Index;
var values = fcurve.Coordinates.Values;
var types = fcurve.InterpolationTypes.Content;
KeyFrames = new List <SoftwareKeyFrame>();
int i2 = 0, loop = values.Length / 2;
for (int i = 0; i != loop; ++i)
{
InterpolationTypes interpolationType = InterpolationTypes.Bezier;
switch (types[i])
{
case 'B': interpolationType = InterpolationTypes.Bezier; break;
case 'L': interpolationType = InterpolationTypes.Linear; break;
case 'C': interpolationType = InterpolationTypes.Constant; break;
}
KeyFrames.Add(new SoftwareKeyFrame(new Vector2(values[i2], values[i2 + 1]), interpolationType));
i2 += 2;
}
}
//------------------------------------------------------------------------------------------------
public FuturesSeriesBuilder(List<string> tickers, List<DateTime> daterange, List<DateTime> holidays,
string futuresStaticMoniker, ICarbonClient client, string carbonEnv = "PRD",
RollMethods rollMthd = RollMethods.FirstNoticeDate,
InterpolationTypes interpType = InterpolationTypes.None,
List<string> contractSortOrder = null,
Dictionary<string,DateTime> rollmap = null,
SmoothingTypes smoothingType = SmoothingTypes.None)
//------------------------------------------------------------------------------------------------
{
initFutureSeriesBuilder(tickers, daterange, holidays, futuresStaticMoniker, client, carbonEnv, rollMthd, interpType, contractSortOrder, rollmap, smoothingType);
}
// Allows intialisation code reuse
//------------------------------------------------------------------------------------------------
private void initFutureSeriesBuilder(List<string> tickers, List<DateTime> daterange, List<DateTime> holidays,
string futuresStaticMoniker, ICarbonClient client, string carbonEnv = "PRD",
RollMethods rolMthd = RollMethods.FirstNoticeDate,
InterpolationTypes interpType = InterpolationTypes.None,
List<string> contractSortOrder = null ,
Dictionary<string,DateTime> rollmap = null,
SmoothingTypes smoothingType = SmoothingTypes.None)
//------------------------------------------------------------------------------------------------
{
// defaults
dateRange_ = daterange;
startDate_ = daterange.Min();
endDate_ = daterange.Max();
carbonEnv_ = carbonEnv;
rollMethod_ = rolMthd; //RollMethods.LastTradeDate; //
holidays_ = holidays;
futuresStaticMoniker_ = futuresStaticMoniker;
interpType_ = interpType;
smoothingType_ = smoothingType;
if (contractSortOrder == null)
{
contractSortOrder_ = new List<string>();
}
else
{
contractSortOrder_ = contractSortOrder;
}
if (rolMthd == RollMethods.Custom && rollmap == null)
{
throw new ArgumentException("Custom roll dates required for custom rolls!");
}
ContractMonthLookupTable_ = new Dictionary<ContractMonths, string>
{
{ContractMonths.PrevFrontMonth, "PrevFront"},
{ContractMonths.FrontMonth, "Front"},
{ContractMonths.BackMonth, "Back"},
{ContractMonths.SecondBackMonth, "SecondBack"}
};
Tuple<List<Tuple<string, ContractMonths>> /*rootTickers*/, List<string> /*contracts*/> tickerListTuple;
// Get Static
FuturesStatic = getFuturesStatic(tickers, futuresStaticMoniker, client, carbonEnv, out tickerListTuple, startDate_, endDate_, contractSortOrder_);
// Add custom roll if present
if (rollmap != null)
{
var sb = new SeriesBuilder<string,DateTime>();
foreach (var kvp in rollmap)
{
sb.Add(kvp.Key, kvp.Value);
}
FuturesStatic.AddColumn("custom_roll", sb.Series);
}
inputTickers_ = tickers;
contractTickers_ = tickerListTuple.Item2;
RollingContractSpecs_ = tickerListTuple.Item1;
var contracts = FuturesStatic.RowKeys.ToList(); // get all the tickers (in case no tickers supplied
// Get prices
Console.WriteLine("Getting Futures prices");
RawFuturesPrices = getAllFuturesPricesInDateRange(contracts, startDate_, endDate_, client);
RawFuturesPrices.Print();
// Align Futures Prices & interpolate gaps
alignRawPriceFrameWithDateRange(dateRange_);
//interpolateRawPriceFrame(interpType_);
}
public SoftwareKeyFrame(Vector2 cordinate, InterpolationTypes interpolationType)
{
Cordinate = cordinate;
InterpolationType = interpolationType;
}
public static Array2D <T> ExtractImageChip <T>(Array2DBase image, ChipDetails chipLocation, InterpolationTypes type = InterpolationTypes.Bilinear)
where T : struct
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (chipLocation == null)
{
throw new ArgumentNullException(nameof(chipLocation));
}
image.ThrowIfDisposed();
chipLocation.ThrowIfDisposed();
if (!chipLocation.IsValid())
{
throw new ArgumentException($"{nameof(chipLocation)} is invalid item.");
}
var chip = new Array2D <T>();
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = NativeMethods.extract_image_chip2(array2DType,
image.NativePtr,
chipLocation.NativePtr,
chip.ImageType.ToNativeArray2DType(),
type.ToNativeInterpolationTypes(),
chip.NativePtr);
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
return(chip);
}
public static extern ErrorType extract_image_chip_matrix2(MatrixElementType img_type, IntPtr in_img, IntPtr chip_location, MatrixElementType array_type, InterpolationTypes type, IntPtr out_chip);
public static extern ErrorType transform_image(Array2DType inType, IntPtr inImg, Array2DType outType, IntPtr outImg, PointMappingTypes pointMappingTypes, IntPtr mappingObj, InterpolationTypes interpolationTypes);
public static extern ErrorType resize_image2(Array2DType inType, IntPtr inImg, Array2DType outType, IntPtr outImg, InterpolationTypes interpolationTypes);
public static void RotateImage(Array2DBase inputImage, Array2DBase outputImage, double angle, InterpolationTypes interpolationTypes = InterpolationTypes.Quadratic)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = NativeMethods.rotate_image2(inType, inputImage.NativePtr, outType, outputImage.NativePtr, angle, interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
}
public static Matrix <T> ResizeImage <T>(Matrix <T> matrix, uint row, uint column, InterpolationTypes interpolationTypes = InterpolationTypes.Bilinear)
where T : struct
{
if (matrix == null)
{
throw new ArgumentNullException(nameof(matrix));
}
matrix.ThrowIfDisposed(nameof(matrix));
var templateRows = (uint)matrix.TemplateRows;
var templateColumns = (uint)matrix.Columns;
var result = Matrix <T> .CreateTemplateParameterizeMatrix(templateRows, templateColumns);
result.SetSize((int)row, (int)column);
ResizeImage(matrix, result, interpolationTypes);
return(result);
}
public KeyFrame(BinaryReader reader)
{
Cordinate = reader.ReadVector2();
InterpolationType = (InterpolationTypes)reader.ReadInt32();
}
private void SetCurveTypeSelector(InterpolationTypes interpolationTypes)
{
if (interpolationTypes == InterpolationTypes.None)
{
foreach (ToolStripMenuItem item in m_curveTypeSelector.DropDownItems)
item.Checked = false;
m_curveTypeSelector.Text = "(Multiple)".Localize("CurveTypeSelector");
}
else
{
foreach (ToolStripMenuItem item in m_curveTypeSelector.DropDownItems)
{
if (((InterpolationTypes)item.Tag == interpolationTypes))
{
item.Checked = true;
m_curveTypeSelector.Text = item.Text;
}
else
item.Checked = false;
}
}
}
// ----------------------------------------------------------------------------------------------------------------------------------------------
#region Lerping
/// <summary>
/// Lerp from float a to b by the factor t (range 0 to 1).
/// Uses smooth (ease-in and -out) interpolation as a default, but supports many different interpolation curves.
/// </summary>
/// <param name="from">The start value (t = 0)</param>
/// <param name="to">The target value (t = 1)</param>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <returns>The interpolated value between from and to.</returns>
public static float Lerp(float from, float to, float t, InterpolationTypes type = InterpolationTypes.Smooth)
{
type = GetSmartType(from, to, type);
t = ApplyLerp(t, type);
return(Mathf.Lerp(from, to, t));
}
public static void ResizeImage(Array2DBase inputImage, Array2DBase outputImage, InterpolationTypes interpolationTypes = InterpolationTypes.Bilinear)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = Native.resize_image2(inType, inputImage.NativePtr, outType, outputImage.NativePtr, interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inputImage.ImageType} is not supported.");
case Native.ErrorType.OutputArrayTypeNotSupport:
throw new ArgumentException($"Output {outputImage.ImageType} is not supported.");
}
}
//------------------------------------------------------------------------------------------------
public Frame<DateTime, string> interpolateRawPriceFrame(Frame<DateTime, string> df, InterpolationTypes interpType)
//------------------------------------------------------------------------------------------------
{
int frameLength = df.RowCount;
int columnCount = df.ColumnCount;
var columns = RawFuturesPrices.Columns;
if (interpType == InterpolationTypes.None) return df;
Dictionary<string, Series<DateTime, double>> resList = new Dictionary<string, Series<DateTime, double>>();
foreach (string colName in RawFuturesPrices.ColumnKeys)
{
var srs = columns[colName];
var idx = df.RowKeys.ToList();
double prev = double.NaN;
idx.Sort();
// Find first non-NaN number
List<int> startIndices = new List<int>();
List<int> endIndices = new List<int>();
SeriesBuilder<DateTime, double> sb = new SeriesBuilder<DateTime, double>();
// Forward pass for start idx
int validIdx = -1;
for (int i = 0; i < frameLength; ++i)
{
double current = srs.TryGetAs<double>(idx[i]).OrDefault(double.NaN);
// Interpolate if missing
if (!double.IsNaN(current))
{
validIdx = i;
//continue;
}
startIndices.Add(validIdx);
}
// Backward pass for end idx
validIdx = -1;
for (int i = frameLength-1; i >= 0; --i)
{
double current = srs.TryGetAs<double>(idx[i]).OrDefault(double.NaN);
// Interpolate if missing
if (!double.IsNaN(current))
{
validIdx = i;
//continue;
}
endIndices.Add(validIdx);
}
endIndices.Reverse();
// Run over and do interpolation
for (int i = 0; i < frameLength; ++i)
{
int startidx = startIndices[i];
int endidx = endIndices[i];
double current = double.NaN;
DateTime dte = idx[i];
// Cases for interpolation....
if (startidx == -1)
{
// Just take last price if it's there
if (endidx == -1) continue;
else
{
startidx = endidx;
}
}
if (endidx == -1)
{
endidx = startidx;
}
if (startidx == endidx)
{
current = srs.GetAs<double>(idx[startidx]);
}
else
{
switch (interpType)
{
case InterpolationTypes.Linear:
DateTime startDate = idx[startidx];
DateTime endDate = idx[endidx];
double startValue = srs.GetAs<double>(startDate);
double endValue = srs.GetAs<double>(endDate);
current = startValue +
(endValue - startValue)*
(dte - startDate).TotalDays / (endDate - startDate).TotalDays;
break;
case InterpolationTypes.FlatForward:
current = srs.GetAs<double>(idx[startidx]);
break;
default:
throw new ArgumentException("Illegal interpolation type (we shouldn't be here...)");
}
}
sb.Add(dte, current);
}
resList[colName] = sb.Series;
}
df = Frame.FromColumns(resList);
return df;
}
public static extern ErrorType rotate_image2(Array2DType inType, IntPtr inImg, Array2DType outType, IntPtr outImg, double angle, InterpolationTypes interpolationTypes);
/// <summary>
/// Lerp from Vector3 a to b by the factor t (range 0 to 1).
/// Uses smooth (ease-in and -out) interpolation as a default, but supports many different interpolation curves.
/// </summary>
/// <param name="from">The start value (t = 0)</param>
/// <param name="to">The target value (t = 1)</param>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <returns>The interpolated value between from and to.</returns>
public static Vector3 Lerp(Vector3 from, Vector3 to, float t, InterpolationTypes type = InterpolationTypes.Smooth)
{
t = ApplyLerp(t, type);
return(Vector3.Lerp(from, to, t));
}
public static extern ErrorType extract_image_chip2(Array2DType img_type, IntPtr in_img, IntPtr chip_location, Array2DType array_type, InterpolationTypes type, IntPtr out_chip);
/// <summary>
/// Lerp from Vector3Int a to b by the factor t (range 0 to 1) with rounding.
/// Uses smooth (ease-in and -out) interpolation as a default, but supports many different interpolation curves.
/// </summary>
/// <param name="from">The start value (t = 0)</param>
/// <param name="to">The target value (t = 1)</param>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <param name="rounding">The type of rounding to apply to the result.</param>
/// <returns>The interpolated value between from and to.</returns>
public static Vector3Int Lerp(Vector3Int from, Vector3Int to, float t, InterpolationTypes type = InterpolationTypes.Smooth, IntRounding rounding = IntRounding.Regular)
{
t = ApplyLerp(t, type);
return(ApplyRounding(Vector3.Lerp(from, to, t), rounding));
}
//------------------------------------------------------------------------------------------------
public FuturesSeriesBuilder(List<string> tickers,
DateTime start,
DateTime end,
string calendarCode,
string futuresStaticMoniker,
ICarbonClient client,
string carbonEnv = "PRD",
RollMethods rollMthd = RollMethods.FirstNoticeDate,
InterpolationTypes interpType = InterpolationTypes.None,
List<string> contractSortOrder = null ,
Dictionary<string,DateTime> rollmap = null,
SmoothingTypes smoothingType = SmoothingTypes.None)
//------------------------------------------------------------------------------------------------
{
// defaults
startDate_ = start;
endDate_ = end;
carbonEnv_ = carbonEnv;
rollMethod_ = rollMthd; //RollMethods.FirstNoticeDate;
smoothingType_ = smoothingType;
futuresStaticMoniker_ = futuresStaticMoniker;
// Holidays
holidays_ = new List<DateTime>();
if (calendarCode != "")
{
var nodaHols = client.GetCalendarAsync(calendarCode).Result.Dates;
foreach (LocalDate hol in nodaHols)
{
holidays_.Add(hol.ToDateTime());
}
}
// DateRange
dateRange_ = new List<DateTime>();
LocalDate currentDate = client.RollDateAsync(DateUtils.ToLocalDate(startDate_), 0, DateUnit.Bd, BusinessDayConvention.Following, calendarCode).Result;
LocalDate endDate = DateUtils.ToLocalDate(endDate_);
while (currentDate <= endDate)
{
dateRange_.Add(DateUtils.ToDateTime(currentDate));
currentDate = client.RollDateAsync(currentDate, 1, DateUnit.Bd, BusinessDayConvention.Following, calendarCode).Result;
}
initFutureSeriesBuilder(tickers, dateRange_, holidays_, futuresStaticMoniker_, client, carbonEnv, rollMthd, interpType, contractSortOrder);
}
/// <summary>
/// Lerp from Quaternion a to b by the factor t (range 0 to 1).
/// Uses smooth (ease-in and -out) interpolation as a default, but supports many different interpolation curves.
/// </summary>
/// <param name="from">The start value (t = 0)</param>
/// <param name="to">The target value (t = 1)</param>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <returns>The interpolated value between from and to.</returns>
public static Quaternion Lerp(Quaternion from, Quaternion to, float t, InterpolationTypes type = InterpolationTypes.Smooth)
{
t = ApplyLerp(t, type);
return(Quaternion.Lerp(from, to, t));
}
public static Matrix <T> ExtractImageChip <T>(MatrixBase image, ChipDetails chipLocation, InterpolationTypes type = InterpolationTypes.NearestNeighbor)
where T : struct
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (chipLocation == null)
{
throw new ArgumentNullException(nameof(chipLocation));
}
image.ThrowIfDisposed();
chipLocation.ThrowIfDisposed();
if (!chipLocation.IsValid())
{
throw new ArgumentException($"{nameof(chipLocation)} is invalid item.");
}
var chip = new Matrix <T>();
var elementType = image.MatrixElementType.ToNativeMatrixElementType();
var ret = NativeMethods.extract_image_chip_matrix2(elementType,
image.NativePtr,
chipLocation.NativePtr,
chip.MatrixElementType.ToNativeMatrixElementType(),
type.ToNativeInterpolationTypes(),
chip.NativePtr);
switch (ret)
{
case NativeMethods.ErrorType.MatrixElementTypeNotSupport:
throw new ArgumentException($"{image.MatrixElementType} is not supported.");
}
return(chip);
}
//------------------------------------------------------------------------------------------------
// Copy constructor
public FuturesSeriesBuilder(FuturesSeriesBuilder copy2clone)
//------------------------------------------------------------------------------------------------
{
// Copy constructor
carbonEnv_ = copy2clone.carbonEnv_;
futuresStaticMoniker_ = copy2clone.futuresStaticMoniker_;
startDate_ = copy2clone.startDate_;
endDate_ = copy2clone.endDate_;
dateRange_ = copy2clone.dateRange_;
holidays_ = copy2clone.holidays_;
rollMethod_ = copy2clone.rollMethod_;
inputTickers_ = copy2clone.inputTickers_;
contractTickers_ = copy2clone.contractTickers_;
RollingContractSpecs_ = copy2clone.RollingContractSpecs_;
ContractMonthLookupTable_ = copy2clone.ContractMonthLookupTable_;
interpType_ = copy2clone.interpType_;
contractSortOrder_ = copy2clone.contractSortOrder_;
smoothingType_ = copy2clone.smoothingType_;
FuturesStatic = copy2clone.FuturesStatic == null ? null : copy2clone.FuturesStatic.Clone();
RawFuturesPrices = copy2clone.RawFuturesPrices == null? null: copy2clone.RawFuturesPrices.Clone();
RollingFuturesData = copy2clone.RollingFuturesData == null? null: copy2clone.RollingFuturesData.Clone();
}
public static void TransformImage(Array2DBase inputImage, Array2DBase outputImage, PointTransformBase pointTransform, InterpolationTypes interpolationTypes = InterpolationTypes.Quadratic)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (pointTransform == null)
{
throw new ArgumentNullException(nameof(pointTransform));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = NativeMethods.transform_image(inType,
inputImage.NativePtr,
outType,
outputImage.NativePtr,
pointTransform.GetNativePointMappingTypes(),
pointTransform.NativePtr,
interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
}
/// <summary>
/// Lerp from int a to b by the factor t (range 0 to 1) with rounding.
/// Uses smooth (ease-in and -out) interpolation as a default, but supports many different interpolation curves.
/// </summary>
/// <param name="from">The start value (t = 0)</param>
/// <param name="to">The target value (t = 1)</param>
/// <param name="t">The interpolation value (range 0 to 1)</param>
/// <param name="type">The interpolation to use</param>
/// <param name="rounding">The type of rounding to apply to the result.</param>
/// <returns>The interpolated value between from and to rounded to the nearest integer.</returns>
public static int Lerp(int from, int to, float t, InterpolationTypes type = InterpolationTypes.Smooth, IntRounding rounding = IntRounding.Regular)
{
type = GetSmartType(from, to, type);
t = ApplyLerp(t, type);
return(ApplyRounding(Mathf.Lerp(from, to, t), rounding));
}
