Converting Engineering Units: Difference between revisions

From Qt Wiki
Jump to navigation Jump to search
(Convert ExpressionEngine links)
m (Petty typo fix: s/your/you're/.)
 
(8 intermediate revisions by 2 users not shown)
Line 1: Line 1:
{{Cleanup | reason=Auto-imported from ExpressionEngine.}}
[[Category:HowTo]]
This How-to explains how to convert double values to QString with units and vice Versa. If you're working in the technical domain surely there will be situation where you need to convert double values like 0.0001V into QString units like 100uV for display purpose in a {{DocLink|QLineEdit}} or {{DocLink|QLabel}}.


h1. '''Conversion of double values(0.0001)=>QString Units(100u) and Vice Versa.'''
And again for actual calculation you need it as a double values. But it will be easy if you have a function to do this conversions.


If your working in the technical domain surely there will be situation where you need to convert double values like 0.0001V into QString units data like(100uV) for display purpose.For example to set in QLineEdit,QLabel etc..
If you need to increment/decrement the 100mV, first you need to convert Qstring 100mV into double 0.1 (crop the 100 from 100mV, divide by 1000 to get 0.1) and then increment/decrement and again we need to convert into incremented 101mV (multiply 0.1 into 1000 and convert into Qstring and add ''mV'' unit to it).


And again for actual calculation you need it in double values.But it will be easy if you have a function to do this conversions.
To make life easier, I created a code snippet with the functions <tt>convertToUnits</tt> and <tt>convertToValues</tt>. It can converts units from nano, micro, milli, deci, kilo and mega.


For scenario,
<tt>convertToUnits</tt> takes double 0.1 as input and returns {{DocLink|QString}} 1000m.
<tt>convertToValues</tt> takes a QString 1000m as input and returns double 0.1.


If you need to increment/decrement the 100mV, first you need to convert Qstring 100mV into double 0.1(crop the 100 from 100mV,divide by 1000 to get 0.1) and then increment/decrement and again we need to convert into incremented 101mV(multiply 0.1 into 1000 and add convert into Qstring and add “mV” unit to it).
<code>
 
QString MainWindow::convertToUnits(double l_nvalue) {
To make life easier,i created a code snippet with functions convertToUnits &amp; convertToValues.It can converts units from nano, micro, milli, deci, kilo &amp; Mega.
 
convertToUnits takes double 0.1 as input and returns Qstring 1000m.
convertToValues takes Qstring 1000m as input and returns double 0.1.
 
Look at the image below for example,
 
[[Image:https://dl.dropboxusercontent.com/u/12382973/testinQT.png|TestinQt]]
 
Functions code:
 
<code>QString TestInQt::convertToUnits(double l_nvalue){
  QString unit;
  QString unit;
  double value;
  double value;


if(l_nvalue<0){
if(l_nvalue < 0) {
value=l_nvalue*–1;
    value = l_nvalue * -1;
  }else
  } else {
value=l_nvalue;
    value = l_nvalue;
}


if(value>=1000000&amp;amp;&amp;value<1000000000){
if(value >= 1000000 && value < 1000000000) {
value=value/1000000; unit="M";
    value = value/1000000;
    unit = "M";
  }
  }
  else if(value>=1000&amp;amp;&amp;value<1000000){
  else if(value>=1000 && value<1000000){
value=value/1000; unit="K";
    value = value/1000;
    unit = "K";
  }
  }
  else if((value>=1&amp;amp;&amp;value<1000))
  else if( value>=1 && value<1000) {
value=value*1;
    value = value*1;
else if((value*1000)>=1&amp;amp;&amp;value<1000){
value=value*1000; unit="m";
  }
  }
  else if((value*1000000)>=1&amp;amp;&amp;value<1000000){
  else if( (value*1000)>=1 && value<1000) {
value=value*1000000; unit=QChar(0x00B5);
    value = value*1000;
    unit = "m";
  }
  }
  else if((value*1000000000)>=1&amp;amp;&amp;value<1000000000){
  else if((value*1000000)>=1 && value<1000000){
value=value*1000000000; unit="n";
    value = value*1000000;
    unit = QChar(0x00B5);
  }
  }
  if(l_nvalue>0)
else if((value*1000000000)>=1 && value<1000000000){
return (QString::number(value)+unit);
    value = value*1000000000;
  if(l_nvalue<0)
    unit = "n";
return (QString::number(value*–1)''unit);
}
 
  if(l_nvalue>0) {
    return (QString::number(value)+unit);
} else
  if(l_nvalue<0) {
    return (QString::number(value*-1)+unit);
}
 
return QString::number(0);
}
}
double TestInQt::convertToValues(QString input){
</code>


QString unit,value;
This is the function for converting the string representation of the value and unit to a double value:
double inValue;
bool ok=true;


int j=0;
<code>
double convertToValues(const QString& input) {
    QRegExp r = QRegExp("^(.+)([nµumKMG])$");
    r.indexIn(input);


for(int i=0;i<=input.count();i){
    if ( r.captureCount() == 2 ) {
if((input[i]>='A'&amp;&amp;input[i]<='Z')||(input[i]>='a'&amp;&amp;input[i]<='z')||(input[i]QChar(0x2126))||(input[i]QChar(0x00B5))){
unit[j]=input[i];
j;
}
}
for(int k=0;k<(input.count()-unit.count());k''+)
value[k]=input[k];


inValue=value.toDouble(&amp;ok);
        QString strValue = r.cap(1);
        QString unit = r.cap(2);


if(unit[0]&amp;#39;n&amp;#39;){
        bool ok = false;
             return(inValue/1000000000);
        double value = strValue.toDouble(&ok);
        if ( !ok ) {
             return input.toDouble();
         }
         }
         else if((unit[0]QChar(0x00B5))||(unit[0]&amp;#39;u&amp;#39;)){
 
             return(inValue/1000000);
         if ( unit == "n" ) {
            return (value*1e-9);
        } else
        if ( unit == "u" || unit == "µ" ) {
            return (value*1e-6);
        } else
        if ( unit == "m" ) {
            return (value*1e-3);
        } else
        if ( unit == "K" ) {
            return (value*1e3);
        } else
        if ( unit == "M" ) {
            return (value*1e6);
        } else
        if ( unit == "G" ) {
             return (value*1e9);
         }
         }
         else if(unit[0]'m'){
 
return(inValue/1000);
         return value;
}
    }
else if(unit[0]&amp;#39;K&amp;#39;){
 
            return(inValue*1000);
    return 0;
        }
        else if(unit[0]'M'){
return(inValue*1000000);
}
else{
return(inValue*1);
}
}
}
</code>
</code>
I also attached the [https://dl.dropboxusercontent.com/u/12382973/testInQt.tar.gz Source Code] project file.


Hope it helped you.
As you can see here we use a regular expression for splitting the value and the unit. The value is then multiplied by the corresponding amount according to the unit prefix. Here we only cover a limited range of prefixes. For a full list see the [https://en.wikipedia.org/wiki/Unit_prefix Wikipedia entry]. In this context the difference between binary and metric prefixes might also be of interest.

Latest revision as of 14:15, 29 February 2016

This How-to explains how to convert double values to QString with units and vice Versa. If you're working in the technical domain surely there will be situation where you need to convert double values like 0.0001V into QString units like 100uV for display purpose in a QLineEdit or QLabel.

And again for actual calculation you need it as a double values. But it will be easy if you have a function to do this conversions.

If you need to increment/decrement the 100mV, first you need to convert Qstring 100mV into double 0.1 (crop the 100 from 100mV, divide by 1000 to get 0.1) and then increment/decrement and again we need to convert into incremented 101mV (multiply 0.1 into 1000 and convert into Qstring and add mV unit to it).

To make life easier, I created a code snippet with the functions convertToUnits and convertToValues. It can converts units from nano, micro, milli, deci, kilo and mega.

convertToUnits takes double 0.1 as input and returns QString 1000m. convertToValues takes a QString 1000m as input and returns double 0.1.

QString MainWindow::convertToUnits(double l_nvalue) {
 QString unit;
 double value;

 if(l_nvalue < 0) {
     value = l_nvalue * -1;
 } else {
     value = l_nvalue;
 }

 if(value >= 1000000 && value < 1000000000) {
     value = value/1000000;
     unit = "M";
 }
 else if(value>=1000 && value<1000000){
     value = value/1000;
     unit = "K";
 }
 else if( value>=1 && value<1000) {
     value = value*1;
 }
 else if( (value*1000)>=1 && value<1000) {
     value = value*1000;
     unit = "m";
 }
 else if((value*1000000)>=1 && value<1000000){
     value = value*1000000;
     unit = QChar(0x00B5);
 }
 else if((value*1000000000)>=1 && value<1000000000){
     value = value*1000000000;
     unit = "n";
 }

 if(l_nvalue>0) {
     return (QString::number(value)+unit);
 } else
 if(l_nvalue<0) {
     return (QString::number(value*-1)+unit);
 }

 return QString::number(0);
}

This is the function for converting the string representation of the value and unit to a double value:

double convertToValues(const QString& input) {
    QRegExp r = QRegExp("^(.+)([nµumKMG])$");
    r.indexIn(input);

    if ( r.captureCount() == 2 ) {

        QString strValue = r.cap(1);
        QString unit = r.cap(2);

        bool ok = false;
        double value = strValue.toDouble(&ok);
        if ( !ok ) {
            return input.toDouble();
        }

        if ( unit == "n" ) {
            return (value*1e-9);
        } else
        if ( unit == "u" || unit == "µ" ) {
            return (value*1e-6);
        } else
        if ( unit == "m" ) {
            return (value*1e-3);
        } else
        if ( unit == "K" ) {
            return (value*1e3);
        } else
        if ( unit == "M" ) {
            return (value*1e6);
        } else
        if ( unit == "G" ) {
            return (value*1e9);
        }

        return value;
    }

    return 0;
}

As you can see here we use a regular expression for splitting the value and the unit. The value is then multiplied by the corresponding amount according to the unit prefix. Here we only cover a limited range of prefixes. For a full list see the Wikipedia entry. In this context the difference between binary and metric prefixes might also be of interest.