Dio la casualidad de que no he podido codificar activamente durante cinco años. Así que cada oportunidad de meterse en el código y meterse con tus camaradas se percibe con alegría, como una oportunidad para sacudir los viejos tiempos y asegurarte de que todavía hay "bayas en las nalgas" (también conocido como un punzón en el culo). Sí, y de inmediato haré una reserva de que el artículo es más un tutorial, no de la serie "Mira lo genial que puedo", sino de la serie "Oh, qué buena opción para mostrar con un simple ejemplo el uso de una tecnología que causa dificultades a algunos compañeros". Creo profundamente que estas soluciones deberían incluirse en el arsenal de cualquier desarrollador de C #.
Acabo de revisar el código, que incluye un proceso de aproximación de varios pasos, en el que se involucra activamente la obtención constante del coeficiente (El coeficiente se selecciona para un rango de valores. va de la tabla IGalla CSF según la velocidad actual del cuerpo (el rango de velocidades corresponde a un CSF específico, unos 300 elementos en la tabla).
El proceso es de varios pasos, la operación de búsqueda se realiza a menudo, y los niños-desarrolladores fueron geniales, fueron incluso más allá de la búsqueda binaria, implementaron el cálculo de una clave entera para un rango de valores y obtuvieron un coeficiente para esta clave a través de Dictionary
Y desde el equipo Agile, y yo, feo, también SixSigma y Realmente me gusta ver todo en números: los muchachos mostraron de manera convincente la efectividad de la solución elegida. Para 1 cálculo a partir de 1000 puntos de aproximación, los costos son:
Búsqueda lineal en la tabla - 0,6 ms
Búsqueda lineal con cadena if-return
- 0,1 ms
Búsqueda por reducción a la mitad - 0,08 ms Búsqueda por diccionario - 0,018 ms
Llegó a mi escritorio en el momento en que el proyecto subió al escenario "y ahora estamos haciendo los mismos cálculos en el microcontrolador". Resultó que la transferencia del diccionario de alguna manera no fue muy buena (sí, podrían haberlo pensado de antemano, pero se enfrentaron a microcontroladores por primera vez, así que los perdonaremos por esta omisión).
Gracias al equipo, ya han contado los números para "pensar" y noté que la ganancia de "código limpio" frente a la búsqueda en la estructura de datos es 6 veces (primeras líneas). Y guardar el diccionario contra la reducción a la mitad, un poco más de 4 veces.
“ ”, - -, data-driven , 20 . - .NET “ ”. if , Linq ? , . , , “” .
- . . - - . - if, , - if, .
if, , . - range (), , (value), (v) . , , Linq - , if if.
If (v >= from && v < to) return value;
public Expression CreateSimpleIf(double from, double to,
double value,
Expression v, LabelTarget returnTarget)
{
var returnStmt = Expression.Return(
returnTarget,
Expression.Constant(value));
var ifCondition = Expression.AndAlso(
Expression.GreaterThanOrEqual(v, Expression.Constant(from)),
Expression.LessThan(v, Expression.Constant(to)));
return Expression.IfThen(ifCondition, returnStmt);
}
. 1 2 , , -, , .
, .
if (v >= mid.from && v < mid.to)
return mid.value
if (v < mid.from)
return search in (0...mid-1)
else
return search in (mid + 1...length - 1);
Span
/ / “ ”.
public Expression CreateSpanExpression(Span<Coefficient> span,
Expression v,
LabelTarget returnTarget)
{
if (span.Length == 1)
return CreateSimpleIf(span[0].RangeFrom,
span[0].RangeTo,
span[0].Value,
v, returnTarget);
else if (span.Length == 2)
{
Expression[] ifs = new Expression[2];
ifs[0] = CreateSimpleIf(span[0].RangeFrom,
span[0].RangeTo,
span[0].Value,
v, returnTarget);
ifs[1] = CreateSimpleIf(span[1].RangeFrom,
span[1].RangeTo,
span[1].Value,
v, returnTarget);
return Expression.Block(ifs);
}
else
{
int mid = span.Length / 2;
Expression[] blocks = new Expression[2];
blocks[0] = CreateSimpleIf(span[mid].RangeFrom,
span[mid].RangeTo,
span[mid].Value,
v, returnTarget);
var leftSide =
CreateSpanExpression(span.Slice(0, mid),
v, returnTarget);
var rightSide =
CreateSpanExpression(span.Slice(mid + 1,
span.Length - mid - 1),
v, returnTarget);
Expression condition =
Expression.LessThan(v,
Expression.Constant(span[mid].RangeFrom));
blocks[1] = Expression.IfThenElse(condition, leftSide, rightSide);
return Expression.Block(blocks);
}
}
- . , , lambda- .
public Func<double, double> CreateBTReeExpression()
{
var value = Expression.Parameter(typeof(double), "value");
var returnTarget = Expression.Label(typeof(double));
var ifs = CreateSpanExpression(mCoefficients.ToArray(),
value, returnTarget);
var body = Expression.Block(typeof(double),
new Expression[]
{
ifs,
Expression.Label(returnTarget,
Expression.Constant(0.0))
});
var expression = Expression.Lambda(typeof(Func<double, double>),
body,
new ParameterExpression[] { value });
var functionDelegate = expression.Compile();
return (Func<double, double>) functionDelegate;
}
, , ? 0.012ms, 1.5 Dictionary
. .
, , , “” - , , , “” . , - , .
, , , “ IDE” , .
, , , , - , , , , ( , ). “, ”.
, – , , . silver bullet .
P.S.: , , . - , , , , , . , , , . .