E_SERIE Class Reference

#include <eserie.h>

Public Member Functions
	E_SERIE ()
void	Exclude (double aValue)
	If any value of the selected E-serie not available, it can be entered as an exclude value. More...
void	NewCalc ()
	initialize next calculation and erase results from previous calculation More...
void	Calculate ()
	called on calculate button to execute all the 2R, 3R and 4R calculations More...
void	SetSeries (uint32_t aSeries)
	Interface for CheckBox, RadioButton, RequriedResistor and calculated Results. More...
void	SetRequiredValue (double aValue)
const std::array< R_DATA, S4R+1 > &	GetResults ()

Private Member Functions
int	buildSerieData (int aEserie, double aList[])
	Build the list of R_DATA existing for a given serie Series are E1, E6 . More...
uint32_t	combine2 ()
	Build all 2R combinations from the selected E-serie values. More...
void	simple_solution (uint32_t aSize)
	Search for closest two component solution. More...
void	combine3 (uint32_t aSize)
	Check if there is a better 3 R solution than previous one using only two components. More...
void	combine4 (uint32_t aSize)
	Check if there is a better four component solution. More...
void	strip3 ()
void	strip4 ()

Private Attributes
std::vector< std::vector< R_DATA > >	m_luts
std::vector< R_DATA >	m_cmb_lut
std::array< R_DATA, S4R+1 >	m_results
uint32_t	m_series = E6
uint32_t	m_enable_4R = false
double	m_required_value = 0.0

Detailed Description

Definition at line 88 of file eserie.h.

Constructor & Destructor Documentation

E_SERIE()

E_SERIE::E_SERIE

(

)

Definition at line 86 of file eserie.cpp.

{
 // Build the list of available resistor values in each En serie
 double listValuesE1[] = { E1_VALUES };
 double listValuesE3[] = { E3_VALUES };
 double listValuesE6[] = { E6_VALUES };
 double listValuesE12[] = { E12_VALUES };
 double listValuesE24[] = { E24_VALUES };
 // buildSerieData must be called in the order of En series, because
 // the list of series is expected indexed by En for the serie En
 buildSerieData( E1, listValuesE1 );
 buildSerieData( E3, listValuesE3 );
 buildSerieData( E6, listValuesE6 );
 buildSerieData( E12, listValuesE12 );
 int count = buildSerieData( E24, listValuesE24 );

 // Reserve a buffer for intermediate calculations:
 // the buffer size is 2*count*count to store all combinaisons of 2 values
 // there are 2*count*count = 29282 combinations for E24
 int bufsize = 2*count*count;
 m_cmb_lut.reserve( bufsize );

 // Store predefined R_DATA items.
 for( int ii = 0; ii < bufsize; ii++ )
 m_cmb_lut.emplace_back( "", 0.0 );
}

References buildSerieData(), E1, E12, E12_VALUES, E1_VALUES, E24, E24_VALUES, E3, E3_VALUES, E6, E6_VALUES, and m_cmb_lut.

Member Function Documentation

buildSerieData()

int E_SERIE::buildSerieData ( int  aEserie, double  aList[]  )

private

Build the list of R_DATA existing for a given serie Series are E1, E6 .

The values are extracted from the E96_VALUES list

Returns

the count of items added in list

Definition at line 114 of file eserie.cpp.

{
 double curr_coeff = FIRST_VALUE;
 int count = 0;

 std::vector<R_DATA> curr_list;

 for( ; ; )
 {
 double curr_r = curr_coeff;

 for( int ii = 0; ; ii++ )
 {
 if( aList[ii] == 0.0 ) // End of list
 break;

 double curr_r = curr_coeff * aList[ii];
 curr_list.emplace_back( strValue( curr_r ), curr_r );
 count++;

 if( curr_r >= LAST_VALUE )
 break;
 }

 if( curr_r >= LAST_VALUE )
 break;

 curr_coeff *= 10;
 }

 m_luts.push_back( std::move( curr_list ) );

 return count;
}

References FIRST_VALUE, LAST_VALUE, m_luts, and strValue().

Referenced by E_SERIE().

Calculate()

void E_SERIE::Calculate

(

)

called on calculate button to execute all the 2R, 3R and 4R calculations

Definition at line 338 of file eserie.cpp.

{
 uint32_t no_of_2Rcombi = 0;

 no_of_2Rcombi = combine2(); // combine all 2R combinations for selected E serie
 simple_solution( no_of_2Rcombi ); // search for simple 2 component solution

 if( m_results.at( S2R ).e_value ) // if simple 2R result is not exact
 combine3( no_of_2Rcombi ); // continiue searching for a possibly better solution

 strip3();
 strip4();
}

References combine2(), combine3(), m_results, S2R, simple_solution(), strip3(), and strip4().

Referenced by PANEL_E_SERIE::OnCalculateESeries().

combine2()

uint32_t E_SERIE::combine2 ( )

private

Build all 2R combinations from the selected E-serie values.

Pre-calculated value combinations are saved in intermediate look up table m_cmb_lut

Returns

is the number of found combinations what also depends from exclude values

Definition at line 251 of file eserie.cpp.

{
 uint32_t combi2R = 0; // target index counts calculated 2R combinations
 std::string s;

 for( const R_DATA& i : m_luts[m_series] ) // outer loop to sweep selected source lookup table
 {
 if( i.e_use )
 {
 for( const R_DATA& j : m_luts[m_series] ) // inner loop to combine values with itself
 {
 if( j.e_use )
 {
 m_cmb_lut.at( combi2R ).e_use = true;
 m_cmb_lut.at( combi2R ).e_value = i.e_value + j.e_value; // calculate 2R serial
 s = i.e_name;
 s.append( " + " );
 m_cmb_lut.at( combi2R ).e_name = s.append( j.e_name);
 combi2R++; // next destination
 m_cmb_lut.at( combi2R ).e_use = true; // calculate 2R parallel
  m_cmb_lut.at( combi2R ).e_value = i.e_value * j.e_value / ( i.e_value + j.e_value );
 s = i.e_name;
 s.append( " | " );
 m_cmb_lut.at( combi2R ).e_name = s.append( j.e_name );
 combi2R++; // next destination
 }
 }
 }
 }
 return combi2R;
}

References m_cmb_lut, m_luts, and m_series.

Referenced by Calculate().

combine3()

void E_SERIE::combine3 ( uint32_t  aSize )

private

Check if there is a better 3 R solution than previous one using only two components.

Parameters

aSize

gives the number of available combinations to be checked inside m_cmb_lut Therefore m_cmb_lut is combinated with the primary E-serie look up table The 3R result with smallest deviation will be saved in results if better than 2R

Definition at line 284 of file eserie.cpp.

{
 uint32_t j = 0;
 double tmp = 0; // avoid warning for being uninitialized
 std::string s;

 m_results.at( S3R ).e_use = false; // disable 3R solution, until
 m_results.at( S3R ).e_value = m_results.at( S2R ).e_value; // 3R becomes better than 2R solution

 for( const R_DATA& i : m_luts[m_series] ) // 3R Outer loop to selected primary E serie LUT
 {
 if( i.e_use ) // skip all excluded values
 {
 for( j = 0; j < aSize; j++ ) // inner loop combines with all 2R intermediate results
 { // R+2R serial combi
 tmp = m_cmb_lut.at( j ).e_value + i.e_value;
 tmp -= m_required_value; // calculate deviation

 if( abs( tmp ) < abs( m_results.at( S3R ).e_value ) ) // compare if better
 { // then take it
 s = i.e_name; // mention 3rd component
 s.append( " + ( " ); // in series
 s.append( m_cmb_lut.at( j ).e_name ); // with 2R combination
 s.append( " )" );
 m_results.at( S3R ).e_name = s; // save S3R result
 m_results.at( S3R ).e_value = tmp; // save amount of benefit
 m_results.at( S3R ).e_use = true; // enable later use
 }

 tmp = i.e_value * m_cmb_lut.at( j ).e_value /
 ( i.e_value + m_cmb_lut.at( j ).e_value ); // calculate R + 2R parallel
 tmp -= m_required_value; // calculate deviation

 if( abs( tmp ) < abs( m_results.at( S3R ).e_value ) ) // compare if better
 { // then take it
 s = i.e_name; // mention 3rd component
 s.append( " | ( " ); // in parallel
 s.append( m_cmb_lut.at( j ).e_name ); // with 2R combination
 s.append( " )" );
 m_results.at( S3R ).e_name = s;
 m_results.at( S3R ).e_value = tmp; // save amount of benefit
 m_results.at( S3R ).e_use = true; // enable later use
 }
 }
 }
 }

 // If there is a 3R result with remaining deviation consider to search a possibly better 4R solution
 // calculate 4R for small series always
 if(( m_results.at( S3R ).e_use == true ) && tmp )
 combine4( aSize );
}

References combine4(), m_cmb_lut, m_luts, m_required_value, m_results, m_series, S2R, and S3R.

Referenced by Calculate().

combine4()

void E_SERIE::combine4 ( uint32_t  aSize )

private

Check if there is a better four component solution.

Parameters

aSsize

gives the number of 2R combinations to be checked inside m_cmb_lut Occupied calculation time depends from number of available E-serie values with the power of 4 why execution for E12 is conditional with 4R check box for the case the previously found 3R solution is already exact

Definition at line 181 of file eserie.cpp.

{
 uint32_t i,j;
 double tmp;
 std::string s;

 m_results.at( S4R ).e_use = false; // disable 4R solution, until
 m_results.at( S4R ).e_value = m_results.at( S3R ).e_value; // 4R becomes better than 3R solution

 #ifdef BENCHMARK
 PROF_COUNTER timer; // start timer to count execution time
 #endif

 for( i = 0; i < aSize; i++ ) // 4R search outer loop
 { // scan valid intermediate 2R solutions
  for( j = 0; j < aSize; j++ ) // inner loop combines all with itself
 {
 tmp = m_cmb_lut.at( i ).e_value + m_cmb_lut.at( j ).e_value; // calculate 2R+2R serial
 tmp -= m_required_value; // calculate 4R deviation

 if( abs( tmp ) < abs( m_results.at(S4R).e_value ) ) // if new 4R is better
 {
 m_results.at( S4R ).e_value = tmp; // save amount of benefit
 std::string s = "( ";
 s.append( m_cmb_lut.at( i ).e_name ); // mention 1st 2 component
 s.append( " ) + ( " ); // in series
 s.append( m_cmb_lut.at( j ).e_name ); // with 2nd 2 components
 s.append( " )" );
 m_results.at( S4R ).e_name = s; // save the result and
 m_results.at( S4R ).e_use = true; // enable for later use
 }

 tmp = ( m_cmb_lut[i].e_value * m_cmb_lut.at( j ).e_value ) /
 ( m_cmb_lut[i].e_value + m_cmb_lut.at( j ).e_value ); // calculate 2R|2R parallel
 tmp -= m_required_value; // calculate 4R deviation

 if( abs( tmp ) < abs( m_results.at( S4R ).e_value ) ) // if new 4R is better
 {
 m_results.at( S4R ).e_value = tmp; // save amount of benefit
 std::string s = "( ";
 s.append( m_cmb_lut.at( i ).e_name ); // mention 1st 2 component
 s.append( " ) | ( " ); // in parallel
 s.append( m_cmb_lut.at( j ).e_name ); // with 2nd 2 components
 s.append( " )" );
 m_results.at( S4R ).e_name = s; // save the result
 m_results.at( S4R ).e_use = true; // enable later use
 }
 }
 }

 #ifdef BENCHMARK
 printf( "Calculation time = %d mS", timer.msecs() );
 fflush( 0 );
 #endif
}

References m_cmb_lut, m_required_value, m_results, S3R, and S4R.

Referenced by combine3().

Exclude()

void E_SERIE::Exclude

(

double

aValue

)

If any value of the selected E-serie not available, it can be entered as an exclude value.

Parameters

aValue

is the value to exclude from calculation Values to exclude are set to false in the selected E-serie source lookup table

Definition at line 150 of file eserie.cpp.

{
 if( aValue ) // if there is a value to exclude other than a wire jumper
 {
 for( R_DATA& i : m_luts[m_series] ) // then search it in the selected E-Serie lookup table
 {
 if( i.e_value == aValue ) // if the value to exclude is found
 i.e_use = false; // disable its use
 }
 }
}

References m_luts, and m_series.

Referenced by PANEL_E_SERIE::OnCalculateESeries().

GetResults()

const std::array<R_DATA,S4R+1>& E_SERIE::GetResults ( )

inline

Definition at line 118 of file eserie.h.

{ return m_results; }

References m_results.

Referenced by PANEL_E_SERIE::OnCalculateESeries().

NewCalc()

void E_SERIE::NewCalc

(

)

initialize next calculation and erase results from previous calculation

Definition at line 238 of file eserie.cpp.

{
 for( R_DATA& i : m_cmb_lut )
 i.e_use = false; // before any calculation is done, assume that

 for( R_DATA& i : m_results )
 i.e_use = false; // no combinations and no results are available

 for( R_DATA& i : m_luts[m_series])
 i.e_use = true; // all selected E-values available
}

References m_cmb_lut, m_luts, m_results, and m_series.

Referenced by PANEL_E_SERIE::OnCalculateESeries().

SetRequiredValue()

void E_SERIE::SetRequiredValue ( double  aValue )

inline

Definition at line 115 of file eserie.h.

{ m_required_value = aValue; }

References m_required_value.

Referenced by PANEL_E_SERIE::OnCalculateESeries().

SetSeries()

void E_SERIE::SetSeries ( uint32_t  aSeries )

inline

Interface for CheckBox, RadioButton, RequriedResistor and calculated Results.

Definition at line 114 of file eserie.h.

{ m_series = aSeries; }

References m_series.

Referenced by PANEL_E_SERIE::OnESeriesSelection().

simple_solution()

void E_SERIE::simple_solution ( uint32_t  aSize )

private

Search for closest two component solution.

Parameters

aSize

is the number of valid 2R combinations in m_cmb_lut on where to search The 2R result with smallest deviation will be saved in results

Definition at line 163 of file eserie.cpp.

{
 uint32_t i;

 m_results.at( S2R ).e_value = std::numeric_limits<double>::max(); // assume no 2R solution or max deviation

 for( i = 0; i < aSize; i++ )
 {
 if( abs( m_cmb_lut.at( i ).e_value - m_required_value ) < abs( m_results.at( S2R ).e_value ) )
 {
 m_results.at( S2R ).e_value = m_cmb_lut.at( i ).e_value - m_required_value; // save signed deviation in Ohms
 m_results.at( S2R ).e_name = m_cmb_lut.at( i ).e_name; // save combination text
 m_results.at( S2R ).e_use = true; // this is a possible solution
 }
 }
}

References m_cmb_lut, m_required_value, m_results, and S2R.

Referenced by Calculate().

strip3()

void E_SERIE::strip3 ( )

private

Definition at line 353 of file eserie.cpp.

{
 std::string s;

 if( m_results.at( S3R ).e_use ) // if there is a 3 term result available
 { // what is connected either by two "|" or by 3 plus
 s = m_results.at( S3R ).e_name;

 if( ( std::count( s.begin(), s.end(), '+' ) == 2 )
 || ( std::count( s.begin(), s.end(), '|' ) == 2 ) )
 { // then strip one pair of braces
 s.erase( s.find( "(" ), 1 ); // it is known sure, this is available
 s.erase( s.find( ")" ), 1 ); // in any unstripped 3R result term
 m_results.at( S3R ).e_name = s; // use stripped result
 }
 }
}

References m_results, and S3R.

Referenced by Calculate().

strip4()

void E_SERIE::strip4 ( )

private

Definition at line 372 of file eserie.cpp.

{
 std::string s;

 if( m_results.at( S4R ).e_use ) // if there is a 4 term result available
 { // what are connected either by 3 "+" or by 3 "|"
 s = m_results.at( S4R ).e_name;

 if( ( std::count( s.begin(), s.end(), '+' ) == 3 )
 || ( std::count( s.begin(), s.end(), '|' ) == 3 ) )
 { // then strip two pair of braces
 s.erase( s.find( "(" ), 1 ); // it is known sure, they are available
 s.erase( s.find( ")" ), 1 ); // in any unstripped 4R result term
 s.erase( s.find( "(" ), 1 );
 s.erase( s.find( ")" ), 1 );
 m_results.at( S4R ).e_name = s; // use stripped result
 }
 }
}

References m_results, and S4R.

Referenced by Calculate().

Member Data Documentation

m_cmb_lut

std::vector<R_DATA> E_SERIE::m_cmb_lut

private

Definition at line 195 of file eserie.h.

Referenced by combine2(), combine3(), combine4(), E_SERIE(), NewCalc(), and simple_solution().

m_enable_4R

uint32_t E_SERIE::m_enable_4R = false

private

Definition at line 199 of file eserie.h.

m_luts

std::vector<std::vector<R_DATA> > E_SERIE::m_luts

private

Definition at line 183 of file eserie.h.

Referenced by buildSerieData(), combine2(), combine3(), Exclude(), and NewCalc().

m_required_value

double E_SERIE::m_required_value = 0.0

private

Definition at line 200 of file eserie.h.

Referenced by combine3(), combine4(), SetRequiredValue(), and simple_solution().

m_results

std::array<R_DATA, S4R+1> E_SERIE::m_results

private

Definition at line 197 of file eserie.h.

Referenced by Calculate(), combine3(), combine4(), GetResults(), NewCalc(), simple_solution(), strip3(), and strip4().

m_series

uint32_t E_SERIE::m_series = E6

private

Definition at line 198 of file eserie.h.

Referenced by combine2(), combine3(), Exclude(), NewCalc(), and SetSeries().

---

The documentation for this class was generated from the following files:

• eserie.h
• eserie.cpp