public string ToolTipTextForRow(int observedDataRowIndex)
{
var column = _observedData.ColumnWithValueBelowLLOQ(observedDataRowIndex);
if (column == null)
{
return(string.Empty);
}
var baseValue = convertCellToFloat(observedDataRowIndex, column);
var displayValue = column.ConvertToDisplayUnit(baseValue);
var valueAsString = _numericFormatter.Format(displayValue);
return(ToolTips.LLOQTooltip(column.Name, valueAsString, column.DisplayUnit.ToString(), column.ConvertToDisplayUnit(column.DataInfo.LLOQ)));
}
private string displayValueFor(OriginDataParameter originDataParameter)
{
var dimension = _dimensionRepository.DimensionForUnit(originDataParameter.Unit);
var displayUnit = dimension.UnitOrDefault(originDataParameter.Unit);
return(_formatter.Format(dimension.BaseUnitValueToUnitValue(displayUnit, originDataParameter.Value)));
}
public void should_return_invalid()
{
sut.IsValid().ShouldBeFalse();
var message = sut.Validate().Message;
message.Contains($"{_numericFormatter.Format(2)} h").ShouldBeTrue();
}
private DataTable createTableFor(string tableName, DataColumn baseGridColumn, IEnumerable <DataColumn> columnsToExport, Func <DataColumn, string> columnNameRetriever, Func <DataColumn, IDimension> dimensionRetriever, bool formatOutput, bool useDisplayUnit)
{
var dataTable = new DataTable(tableName);
//user string because we want to export the unit
var allColumns = columnsToExport.Where(col => !col.IsBaseGrid())
.Where(x => x.BaseGrid == baseGridColumn).ToList();
moveDrugColumnsFirst(allColumns);
allColumns.Insert(0, baseGridColumn);
var cacheName = retrieveUniqueNameForColumns(allColumns, columnNameRetriever);
var cacheDimensions = retrieveDimensionsFor(allColumns, dimensionRetriever);
allColumns.Each(x =>
{
var column = dataTable.Columns.Add(cacheName[x], formatOutput ? typeof(string) : typeof(float));
column.ExtendedProperties.Add(Constants.DATA_REPOSITORY_COLUMN_ID, x.Id);
});
//add units information
for (int i = 0; i < dataTable.Columns.Count; i++)
{
var col = dataTable.Columns[i];
var dataColumn = allColumns[i];
var dimension = cacheDimensions[dataColumn];
var unit = unitFor(dimension, dataColumn, useDisplayUnit);
if (!string.IsNullOrWhiteSpace(unit.Name))
{
col.ColumnName = $"{col.ColumnName} [{unit.Name}]";
}
}
for (int i = 0; i < baseGridColumn.Values.Count; i++)
{
var row = dataTable.NewRow();
for (int j = 0; j < allColumns.Count; j++)
{
var columnToExport = allColumns[j];
var dimension = cacheDimensions[columnToExport];
var unit = unitFor(dimension, columnToExport, useDisplayUnit);
double value = dimension.BaseUnitValueToUnitValue(unit, columnToExport.Values[i]);
if (formatOutput)
{
row[j] = _numericFormatter.Format(value);
}
else
{
row[j] = value;
}
}
dataTable.Rows.Add(row);
}
return(dataTable);
}
private Func <double, object> valueFormatterFor(bool formatOutput)
{
if (formatOutput)
{
return(v => _numericFormatter.Format(v));
}
return(v => v);
}
public void Nullable_Integer_No_Value()
{
int?testVal = null;
var formatter = new NumericFormatter();
var result = formatter.Format(testVal, 0);
Assert.Single(result);
Assert.True(result.ContainsKey(string.Empty), "Should have a single, empty key");
Assert.Equal(result[string.Empty], string.Empty);
}
public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
var d = (double?)value;
if (!d.HasValue)
{
return;
}
var formatted = _doubleFormatter.Format(d.Value);
double.TryParse(formatted, out double roundedFromString);
writer.WriteValue(roundedFromString);
}
private static string messagesForInconsistentExtremes(
IEnumerable <ParameterSelection> allInconsistentExtremes,
Func <string, string, string, string> extremeAllowedFunc,
Func <string, string, string, string> extremeNotAllowedFunc,
Func <IParameter, bool> extremeIsAllowed,
Func <IParameter, double?> valueFunc)
{
return(allInconsistentExtremes.Select(x =>
{
var parameter = x.Parameter;
var value = valueFunc(parameter);
if (!value.HasValue)
{
return string.Empty;
}
var errorRetrieverFunc = extremeIsAllowed(parameter) ? extremeAllowedFunc : extremeNotAllowedFunc;
var formattedDisplayValue = _numericFormatter.Format(parameter.ConvertToDisplayUnit(value.Value));
return errorRetrieverFunc(formattedDisplayValue, parameter.DisplayUnit?.Name, x.FullQuantityPath);
}).Where(x => !string.IsNullOrEmpty(x)).ToString(Environment.NewLine));
}
private string replaceIntervalValue(string label, double value, string intervalPatternLimit)
{
var regex = _intervalRegexCache[intervalPatternLimit];
if (!regex.IsMatch(label))
{
return(label);
}
//default value to use if number was not specified
_numericFormatterOptions.DecimalPlace = _defaultFormatterOptions.DecimalPlace;
uint?numberOfDigits = null;
var group = regex.Match(label).Groups[_numberOfDigitsGroup];
if (group.Success)
{
numberOfDigits = uint.Parse(group.Value);
_numericFormatterOptions.DecimalPlace = numberOfDigits.Value;
}
var intervalPatternToUse = intervalPattern(intervalPatternLimit, numberOfDigits);
return(label.Replace(intervalPatternToUse, _numericFormatter.Format(value)));
}
private static string createRow(DataRowView row, Dictionary <string, char> tableNotes, ITeXConverter converter, ITeXBuilderRepository builderRepository, DataRelation relation = null, int?level = null)
{
var rowLine = new StringBuilder();
rowLine.Append(setPagebreakDesirability(getPagebreakDesirability(row, level)));
var columnsCount = 0;
foreach (DataColumn col in row.DataView.Table.Columns)
{
if (col.IsHidden())
{
continue;
}
if (relation != null)
{
if (relation.ChildColumns.Contains(col))
{
continue;
}
}
columnsCount++;
if (columnsCount > 1)
{
rowLine.AppendFormat(" {0} ", VALUE_SEPARATOR);
}
var colValue = row[col.ColumnName];
if (colValue == null || colValue == DBNull.Value)
{
continue;
}
// datatype specifics
string value;
if (col.DataType == typeof(double) || col.DataType == typeof(float))
{
value = converter.StringToTeX(_numericFormatter.Format(Convert.ToDouble(colValue)));
}
else if (col.DataType == typeof(DateTime))
{
value = converter.StringToTeX(((DateTime)colValue).ToShortTimeString());
}
else if (col.DataType == typeof(Text))
{
value = builderRepository.ChunkFor(colValue);
}
else
{
value = converter.StringToTeX(colValue.ToString());
}
rowLine.Append(value);
}
rowLine.Append(Helper.LineBreak());
rowLine.Append(phantomline());
var first = true;
foreach (DataRelation childrelation in row.DataView.Table.ChildRelations)
{
var childView = row.CreateChildView(childrelation);
if (childView.Count == 0)
{
continue;
}
if (first)
{
rowLine.Append(CLine(1, columnsCount));
first = false;
}
rowLine.Append(multiFirstColumn(columnsCount, ColumnAlignments.c,
createChildTable(childView, tableNotes, childrelation, converter, builderRepository, ref level)));
rowLine.Append(Helper.LineBreak());
rowLine.Append(phantomline());
}
if (row.DataView.Table.ChildRelations.Count > 0)
{
rowLine.Append(CLine(1, columnsCount));
}
return(rowLine.ToString());
}
private string sizeInMb(long sizeInByte) => _fileSizeFormatter.Format(sizeInByte * 1.0 / Constants.MB_TO_BYTES);
private static string displayFor(double value)
{
return(_numericFormatter.Format(value));
}
private IEnumerable <object> reportFor(GenderRatio genderRatio)
{
yield return(this.ReportValue(_infoRepository.DisplayNameFor(genderRatio.Gender), string.Format("{0}%", _formatter.Format(genderRatio.Ratio))));
}
public void should_return_a_message_when_invalid_using_the_display_database_values(double?dbMax, double?valueInHours)
{
InitRange(null, null, null, dbMax);
var formatter = new NumericFormatter <double>(NumericFormatterOptions.Instance);
var validation = sut.Validate(x => x.MaxValueInDisplayUnit, valueInHours);
validation.IsEmpty.ShouldBeEqualTo(false);
validation.Message.ShouldBeEqualTo(PKSimConstants.Rules.Parameter.MaxLessThanDbMaxValue(sut.ParameterName, formatter.Format(sut.DbMaxValueInDisplayUnit.Value), sut.Unit.Name));
}
private string displayValueFor(double kernValue, IDimension dimension, string displayUnitNane)
{
var displayUnit = dimension.UnitOrDefault(displayUnitNane);
return(_formatter.Format(dimension.BaseUnitValueToUnitValue(displayUnit, kernValue)));
}
protected override void FillUpReport(GenderRatio genderRatio, ReportPart reportPart)
{
reportPart.AddToContent("{0} at {1}%", _representationInfoRepository.DisplayNameFor(genderRatio.Gender), _formatter.Format(genderRatio.Ratio));
}
