C#

oRange = oWS.get_Range("B2:B6,D2:D6")

   x      a     b      f  tgt  xrev
-----------------------------------
0,00  10,00  1,00   20,0   20  0,00
0,25   7,75  0,89   62,1   42  0,25
0,50   5,50  0,74  118,7   89  0,50
0,75   3,25  0,51  205,5  189  0,75
1,00   1,00  0,00  400,0  400  1,00

x    : input
a    = 10 - x * 9
b    = log(a)
f    = 400 - b * 380
tgt  : target
xrev = (10-10^((400-f)/380))/9

logf [20.000, 400.000, 101] Hz

DaveyM69 wrote:

Thanks for your help Sascha

float[] logValues = CreateLogValues(20, 400, 101);

public static float[] CreateLogValues(float minimum, float maximum, int valuesCount)
{
    double logarithmicBase = Math.E;
    double logMinimum = Math.Log(minimum);
    double logMaximum = Math.Log(maximum);
    double delta = (logMaximum - logMinimum) / (valuesCount - 1);
    double accumulatedDelta = 0;
    float[] values = new float[valuesCount];
    for (int i = 0; i < valuesCount; ++i)
    {
        values[i] = (float)Math.Pow(logarithmicBase, logMinimum + accumulatedDelta);
        accumulatedDelta += delta;
    }
    return values;
}

DataTable dataTable = new DataTable();

dataTable.Columns.Add("Variable", typeof(string));
dataTable.Columns.Add("Hex Value", typeof(Int64));
dataTable.Columns.Add("Value", typeof(string));
dataTable.Columns.Add("Hide", typeof(bool));

dataTable.Rows.Add("Ronald", 0x0, "Value = 0", false);
dataTable.Rows.Add("Ronald", 0x1, "Value = 1", true);
dataTable.Rows.Add("Ronald", 0x2, "Value = 2", false);
dataTable.Rows.Add("Ronald", 0x4, "Value = 4", true);
dataTable.Rows.Add("Ronald", 0x8, "Value = 8", false);
dataTable.Rows.Add("Ronald", 0x16, "Value = 16", false);
dataTable.Rows.Add("Ronald", 0x32, "Value = 32", false);
dataTable.Rows.Add("Ronald", 0x64, "Value = 64", true);
dataTable.Rows.Add("Ronald", 0x128, "Value = 128", false);
dataTable.Rows.Add("Ronald", 0xFF, "Value = 255", true);

try
{
     DataRow selectedRow = dataTable.Select("").FirstOrDefault(x => (Int64)x["Hex Value"] == Convert.ToInt64(tb_Input.Text, 16));
     lbl_Result.Text = selectedRow["Value"].ToString();
}
catch
{
     lbl_Result.Text = "Unknown";
}

DataRow[] drArrRow = dataTable.Select("Hide = False");
DataTable filteredDataTable = new DataTable();

filteredDataTable.Columns.Add("Variable", typeof(string));
filteredDataTable.Columns.Add("Value", typeof(string));

foreach (DataRow dr in drArrRow)
{
    filteredDataTable.Rows.Add(dr["Variable"], dr["Value"]);
}

string res = String.Join(Environment.NewLine, filteredDataTable.Rows.OfType<DataRow>().Select(x => String.Join(" ; ", x.ItemArray)));

MessageBox.Show(res);

DataRow selectedRow = dataTable.AsEnumerable().SingleOrDefault(x => (Int64)x["Hex Value"] == Convert.ToInt64(tb_Input.Text, 16));
lbl_Result.Text = selectedRow != null ? selectedRow["Value"].ToString() : "Unknown";

var filtered = dataTable.AsEnumerable()
                        .Where(row => !(bool)row["Hide"])
                        .Select(row => new { variable = (string)row["Variable"], value = (string)row["Value"] });
// => "filtered" is a collection of an "anonymous type" with the properties "variable" and "value"
// (an "anonymous type" is a type that the compiler built for you)

// build a CSV-"file":
StringBuilder sb = new StringBuilder();
// output headers:
sb.AppendLine("\"Variable\";\"Value\"");
// output rows:
foreach (var row in filtered)
{
   sb.Append('"').Append(row.variable).Append('"');
   sb.Append(';');
   sb.Append('"').Append(row.value).Append('"');
   sb.AppendLine();
}
string output = sb.ToString();

var filtered = dataTable.AsEnumerable()
                        .Where(row => !(bool)row["Hide"])
                        .Select(row => String.Concat("\"", row["Variable"], "\";\"", row["Value"], "\""));
// => here "filtered" is just a collection of strings

StringBuilder sb = new StringBuilder();
sb.AppendLine("\"Variable\";\"Value\"");
sb.Append(String.Join(Environment.NewLine, filtered));
string output = sb.ToString();