public bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
if (nodes[opIndex] is IndexerNode ix)
{
if (ix.Nodes.Count == 0 && nodes[opIndex - 1].Is <IdentifierNode>().Or <ITypeIdentifier>(out bool isType))
{
ITypeIdentifier arrayedType = isType ? nodes[opIndex - 1] as ITypeIdentifier : new TypeIdentifierNode(nodes[opIndex - 1] as IdentifierNode);
TypeArrayIdentifierNode lookup = new TypeArrayIdentifierNode(arrayedType, nodes[opIndex - 1].Pos);
nodes[opIndex - 1] = lookup;
nodes.RemoveAt(opIndex);
}
else
{
LookupNode lookup = new LookupNode(nodes[opIndex - 1] as IExpr, nodes[opIndex] as IndexerNode, nodes[opIndex - 1].Pos);
caller.Invoke(lookup.Index.Nodes); // Invoke on sub-elements
nodes[opIndex - 1] = lookup;
nodes.RemoveAt(opIndex);
}
return(true);
}
else
{
return(false);
}
}
public LiteQuery OrderBy(string tableAlias, string fieldName, OrderMethod orderMethod = OrderMethod.ASC)
{
LiteOrderField item = new LiteOrderField(tableAlias, fieldName, orderMethod);
this.Orders.Add(item);
return(this);
}
public BucketSort(OrderMethod order, OrderByProperty orderBy, bool multi = false)
{
if (order == OrderMethod.Descending)
{
_ordering = more;
_multiOrder = multiMore;
}
else
{
_ordering = less;
_multiOrder = multiLess;
}
_orderMethod = order;
// Always use Size as the first property to order when multiple properties are enabled
// It defines the initialization of the buckets
if (multi)
{
_orderBy = OrderByProperty.Size;
}
else
{
_orderBy = orderBy;
}
_enableMulti = multi;
}
public static void ApplyOrderOfOperationsBinary(T binOpNode, OrderMethod orderEnforcer)
{
if (binOpNode.Left is IGroupedASTNode leftGroup)
{
orderEnforcer(leftGroup.Nodes);
}
if (binOpNode.Right is IGroupedASTNode rightGroup)
{
orderEnforcer(rightGroup.Nodes);
}
}
public virtual bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
T op = Activator.CreateInstance(typeof(T), nodes[opIndex].Pos) as T;
op.Update(LeftRight.LHS, nodes[opIndex - 1]);
op.Update(LeftRight.RHS, nodes[opIndex + 1]);
ApplyOrderOfOperationsBinary(op, caller);
nodes[opIndex - 1] = op;
nodes.RemoveAt(opIndex + 1);
nodes.RemoveAt(opIndex);
return(true);
}
public override bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
string op = nodes[opIndex].Content;
if (base.ApplyBehaviour(nodes, opIndex, caller))
{
(nodes[opIndex - 1] as BinOpNode).SetOperation(op);
return(true);
}
else
{
return(false);
}
}
public BubbleSort(OrderMethod order, OrderByProperty orderBy, bool multi = false)
{
if (order == OrderMethod.Descending)
{
_ordering = less;
_multiOrder = multiLess;
}
else
{
_ordering = more;
_multiOrder = multiMore;
}
_orderBy = orderBy;
_enableMulti = multi;
}
public bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
if (nodes[opIndex - 1].Is <IdentifierNode>().Is <ThisNode>().Or <MemberAccessNode>() && nodes[opIndex + 1] is IdentifierNode accessId)
{
IExpr accessExpr = nodes[opIndex - 1] as IExpr;
nodes[opIndex - 1] = new MemberAccessNode(accessExpr, accessId, this.m_symbol, nodes[opIndex].Pos);
nodes.RemoveAt(opIndex + 1);
nodes.RemoveAt(opIndex);
return(true);
}
else
{
return(false);
}
}
public bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
this.m_advanceBy = 0;
if (this.m_isPostOp)
{
nodes[opIndex - 1] = new UnaryOpNode(nodes[opIndex].Pos, nodes[opIndex - 1], this.m_symbol, true);
nodes.RemoveAt(opIndex);
this.m_advanceBy = 0;
}
else
{
nodes[opIndex] = new UnaryOpNode(nodes[opIndex].Pos, nodes[opIndex + 1], this.m_symbol, false);
nodes.RemoveAt(opIndex + 1);
this.m_advanceBy = 1;
}
return(true);
}
public QuickSort(OrderMethod order, OrderByProperty orderBy, bool multi = false)
{
if (order == OrderMethod.Descending)
{
_firstMulti = moreMulti;
_secondMulti = lessMulti;
_firstOrder = more;
_secondOrder = less;
}
else
{
_firstMulti = lessMulti;
_secondMulti = moreMulti;
_firstOrder = less;
_secondOrder = more;
}
_orderBy = orderBy;
_enableMulti = multi;
}
public bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
if (this.m_isObj)
{
if (this.m_matchReqParenthesis) // sizeof operator or something
{
throw new NotImplementedException();
}
else
{
nodes[opIndex] = new NewObjectNode((nodes[opIndex + 1] as IdentifierNode).ToTypeIdentifier(), nodes[opIndex + 2] as ExpressionNode, nodes[opIndex].Pos);
nodes.RemoveRange(opIndex + 1, 2);
return(true);
}
}
else
{
var look = nodes[opIndex + 1] as LookupNode;
nodes[opIndex] = new NewArrayNode(look.ToTypeIdentifier(), look.Index, nodes[opIndex].Pos);
nodes.RemoveAt(opIndex + 1);
}
return(true);
}
unsafe void encode_residual(FlacFrame frame, int ch, PredictionType predict, OrderMethod omethod, int pass, int best_window)
{
int* smp = frame.subframes[ch].samples;
int i, n = frame.blocksize;
// save best.window, because we can overwrite it later with fixed frame
// CONSTANT
for (i = 1; i < n; i++)
{
if (smp[i] != smp[0]) break;
}
if (i == n)
{
frame.subframes[ch].best.type = SubframeType.Constant;
frame.subframes[ch].best.residual[0] = smp[0];
frame.subframes[ch].best.size = (uint)frame.subframes[ch].obits;
return;
}
// VERBATIM
frame.current.type = SubframeType.Verbatim;
frame.current.size = (uint)(frame.subframes[ch].obits * frame.blocksize);
frame.ChooseBestSubframe(ch);
if (n < 5 || predict == PredictionType.None)
return;
// FIXED
if (predict == PredictionType.Fixed ||
(predict == PredictionType.Search && pass != 1) ||
//predict == PredictionType.Search ||
//(pass == 2 && frame.subframes[ch].best.type == SubframeType.Fixed) ||
n <= eparams.max_prediction_order)
{
int max_fixed_order = Math.Min(eparams.max_fixed_order, 4);
int min_fixed_order = Math.Min(eparams.min_fixed_order, max_fixed_order);
for (i = min_fixed_order; i <= max_fixed_order; i++)
encode_residual_fixed_sub(frame, i, ch);
}
// LPC
if (n > eparams.max_prediction_order &&
(predict == PredictionType.Levinson ||
predict == PredictionType.Search)
//predict == PredictionType.Search ||
//(pass == 2 && frame.subframes[ch].best.type == SubframeType.LPC))
)
{
float* lpcs = stackalloc float[lpc.MAX_LPC_ORDER * lpc.MAX_LPC_ORDER];
int min_order = eparams.min_prediction_order;
int max_order = eparams.max_prediction_order;
for (int iWindow = 0; iWindow < _windowcount; iWindow++)
{
if (best_window != -1 && iWindow != best_window)
continue;
LpcContext lpc_ctx = frame.subframes[ch].lpc_ctx[iWindow];
lpc_ctx.GetReflection(max_order, smp, n, frame.window_buffer + iWindow * Flake.MAX_BLOCKSIZE * 2);
lpc_ctx.ComputeLPC(lpcs);
//int frameSize = n;
//float* F = stackalloc float[frameSize];
//float* B = stackalloc float[frameSize];
//float* PE = stackalloc float[max_order + 1];
//float* arp = stackalloc float[max_order];
//float* rc = stackalloc float[max_order];
//for (int j = 0; j < frameSize; j++)
// F[j] = B[j] = smp[j];
//for (int K = 1; K <= max_order; K++)
//{
// // BURG:
// float denominator = 0.0f;
// //float denominator = F[K - 1] * F[K - 1] + B[frameSize - K] * B[frameSize - K];
// for (int j = 0; j < frameSize - K; j++)
// denominator += F[j + K] * F[j + K] + B[j] * B[j];
// denominator /= 2;
// // Estimate error
// PE[K - 1] = denominator / (frameSize - K);
// float reflectionCoeff = 0.0f;
// for (int j = 0; j < frameSize - K; j++)
// reflectionCoeff += F[j + K] * B[j];
// reflectionCoeff /= denominator;
// rc[K - 1] = arp[K - 1] = reflectionCoeff;
// // Levinson-Durbin
// for (int j = 0; j < (K - 1) >> 1; j++)
// {
// float arptmp = arp[j];
// arp[j] -= reflectionCoeff * arp[K - 2 - j];
// arp[K - 2 - j] -= reflectionCoeff * arptmp;
// }
// if (((K - 1) & 1) != 0)
// arp[(K - 1) >> 1] -= reflectionCoeff * arp[(K - 1) >> 1];
// for (int j = 0; j < frameSize - K; j++)
// {
// float f = F[j + K];
// float b = B[j];
// F[j + K] = f - reflectionCoeff * b;
// B[j] = b - reflectionCoeff * f;
// }
// for (int j = 0; j < K; j++)
// lpcs[(K - 1) * lpc.MAX_LPC_ORDER + j] = (float)arp[j];
//}
switch (omethod)
{
case OrderMethod.Akaike:
//lpc_ctx.SortOrdersAkaike(frame.blocksize, eparams.estimation_depth, max_order, 7.1, 0.0);
lpc_ctx.SortOrdersAkaike(frame.blocksize, eparams.estimation_depth, max_order, 4.5, 0.0);
break;
default:
throw new Exception("unknown order method");
}
for (i = 0; i < eparams.estimation_depth && i < max_order; i++)
encode_residual_lpc_sub(frame, lpcs, iWindow, lpc_ctx.best_orders[i], ch);
}
}
}
public int flake_set_defaults(int lvl)
{
compression = lvl;
if ((lvl < 0 || lvl > 12) && (lvl != 99))
{
return -1;
}
// default to level 5 params
window_function = WindowFunction.Flattop | WindowFunction.Tukey;
order_method = OrderMethod.Akaike;
stereo_method = StereoMethod.Evaluate;
window_method = WindowMethod.Evaluate;
block_size = 0;
block_time_ms = 105;
prediction_type = PredictionType.Search;
min_prediction_order = 1;
max_prediction_order = 12;
estimation_depth = 1;
min_fixed_order = 2;
max_fixed_order = 2;
min_partition_order = 0;
max_partition_order = 8;
variable_block_size = 0;
lpc_min_precision_search = 1;
lpc_max_precision_search = 1;
do_seektable = true;
// differences from level 7
switch (lvl)
{
case 0:
block_time_ms = 53;
prediction_type = PredictionType.Fixed;
stereo_method = StereoMethod.Independent;
max_partition_order = 6;
break;
case 1:
prediction_type = PredictionType.Levinson;
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Bartlett;
max_prediction_order = 8;
max_partition_order = 6;
break;
case 2:
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Bartlett;
max_partition_order = 6;
break;
case 3:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Bartlett;
max_prediction_order = 8;
break;
case 4:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Bartlett;
break;
case 5:
stereo_method = StereoMethod.Estimate;
window_method = WindowMethod.Estimate;
break;
case 6:
stereo_method = StereoMethod.Estimate;
break;
case 7:
break;
case 8:
estimation_depth = 2;
min_fixed_order = 0;
lpc_min_precision_search = 0;
break;
case 9:
window_function = WindowFunction.Bartlett;
max_prediction_order = 32;
break;
case 10:
min_fixed_order = 0;
max_fixed_order = 4;
max_prediction_order = 32;
//lpc_max_precision_search = 2;
break;
case 11:
min_fixed_order = 0;
max_fixed_order = 4;
max_prediction_order = 32;
estimation_depth = 5;
//lpc_max_precision_search = 2;
variable_block_size = 4;
break;
}
return 0;
}
private static IOrderedEnumerable <T> Order <T>(IEnumerable <T> source, string propertyName, OrderMethod method)
{
Ensure.NotNull(source, nameof(source));
Ensure.NotEmpty(propertyName, nameof(propertyName));
string[] propertyNameParts = propertyName.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach (string propertyNamePart in propertyNameParts)
{
// Use reflection (not ComponentModel) to mirror LINQ
PropertyInfo propertyInfo = type.GetProperty(propertyNamePart);
if (propertyInfo == null)
{
throw new InvalidOperationException($"Nested property with name {propertyName} for type {typeof(T).Name} was not found.");
}
expr = Expression.Property(expr, propertyInfo);
type = propertyInfo.PropertyType;
}
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
object result = typeof(Enumerable).GetMethods().Single(
m => m.Name == method.ToString() &&
m.IsGenericMethodDefinition &&
m.GetGenericArguments().Length == 2 &&
m.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { source, lambda.Compile() });
return((IOrderedEnumerable <T>)result);
}
/// <summary>
/// Apply ordering to sort queryable result.
/// </summary>
/// <typeparam name="T">Type of queryable objects.</typeparam>
/// <param name="query">Query.</param>
/// <param name="propertyName">Name of property.</param>
/// <param name="method">Flag of order method.</param>
/// <returns>
/// Ordered queryable object (IOrderedQueryable).
/// </returns>
/// <remarks>
/// Use reflection (not ComponentModel) to mirror LINQ.
/// </remarks>
private static IOrderedQueryable <T> Order <T>(IQueryable <T> query, string propertyName, OrderMethod method)
{
Ensure.NotNull(query, nameof(query));
Ensure.NotEmpty(propertyName, nameof(propertyName));
string[] propertyNameParts = propertyName.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expression = arg;
foreach (string propertyNamePart in propertyNameParts)
{
PropertyInfo propertyInfo = type.GetProperty(propertyNamePart, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
if (propertyInfo == null)
{
throw new InvalidOperationException($"Nested property with name {propertyName} for type {typeof(T).Name} was not found.");
}
expression = Expression.Property(expression, propertyInfo);
type = propertyInfo.PropertyType;
}
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expression, arg);
object result = typeof(Queryable).GetMethods().Single(
m => m.Name == method.ToString() &&
m.IsGenericMethodDefinition &&
m.GetGenericArguments().Length == 2 &&
m.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { query, lambda });
return((IOrderedQueryable <T>)result);
}
public int flake_set_defaults(FlakeWriterSettings settings)
{
// default to level 7 params
window_function = WindowFunction.Flattop | WindowFunction.Tukey;
order_method = OrderMethod.Akaike;
stereo_method = StereoMethod.Evaluate;
window_method = WindowMethod.Evaluate;
block_time_ms = 105;
prediction_type = PredictionType.Search;
estimation_depth = 1;
variable_block_size = 0;
lpc_min_precision_search = 1;
lpc_max_precision_search = 1;
do_seektable = true;
development_mode = -1;
// differences from level 7
switch (settings.EncoderModeIndex)
{
case 0:
block_time_ms = 53;
prediction_type = PredictionType.Fixed;
stereo_method = StereoMethod.Independent;
break;
case 1:
prediction_type = PredictionType.Levinson;
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Bartlett;
break;
case 2:
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Bartlett;
break;
case 3:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Bartlett;
break;
case 4:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Bartlett;
break;
case 5:
stereo_method = StereoMethod.Estimate;
window_method = WindowMethod.Estimate;
break;
case 6:
stereo_method = StereoMethod.Estimate;
break;
case 7:
break;
case 8:
estimation_depth = 2;
lpc_min_precision_search = 0;
break;
case 9:
window_function = WindowFunction.Bartlett;
break;
case 10:
//lpc_max_precision_search = 2;
break;
case 11:
estimation_depth = 5;
//lpc_max_precision_search = 2;
variable_block_size = 4;
break;
}
return 0;
}
public int set_defaults(int lvl)
{
compression = lvl;
if ((lvl < 0 || lvl > 12) && (lvl != 99))
{
return -1;
}
// default to level 5 params
window_function = WindowFunction.Flattop | WindowFunction.Tukey;
order_method = OrderMethod.Estimate;
stereo_method = StereoMethod.Evaluate;
window_method = WindowMethod.Evaluate;
block_size = 0;
block_time_ms = 105;
min_modifier = 4;
max_modifier = 4;
min_prediction_order = 1;
max_prediction_order = 12;
estimation_depth = 1;
adaptive_passes = 0;
do_seektable = false;
chunk_size = 5;
// differences from level 6
switch (lvl)
{
case 0:
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Hann;
max_prediction_order = 6;
break;
case 1:
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Hann;
max_prediction_order = 8;
break;
case 2:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Hann;
max_prediction_order = 6;
break;
case 3:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Hann;
max_prediction_order = 8;
break;
case 4:
stereo_method = StereoMethod.Estimate;
window_method = WindowMethod.Estimate;
max_prediction_order = 8;
break;
case 5:
stereo_method = StereoMethod.Estimate;
window_method = WindowMethod.Estimate;
break;
case 6:
stereo_method = StereoMethod.Estimate;
break;
case 7:
stereo_method = StereoMethod.Estimate;
adaptive_passes = 1;
min_modifier = 2;
break;
case 8:
adaptive_passes = 1;
min_modifier = 2;
break;
case 9:
adaptive_passes = 1;
max_prediction_order = 30;
min_modifier = 2;
break;
case 10:
estimation_depth = 2;
adaptive_passes = 2;
max_prediction_order = 30;
min_modifier = 2;
break;
}
return 0;
}
