Archive

Archive for the ‘KnowWhat’ Category

How fast is integer arithmetic than floating point arithmetic?

June 19th, 2013 No comments
You may already know that integer arithmetic is faster than floating point arithmetic. But how fast? I had the same question in my mind. So created the following script to test the “fastness” for each data type.

#include <vector>
#include <iostream>
#include <cstdlib>
#include “Stopwatch.hpp”

template <typename T>
void test( size_t inArraySize, size_t inCorpusSize )
{
    typedef std::vector<T> array_t;
    typedef std::vector<array_t> arrays_t;

    std::cout << “constructing the corpus…”;

    Stopwatch sw;
    sw.Start();
    arrays_t corpus( inCorpusSize + 1);
    for ( size_t i = 0; i < inCorpusSize+1; ++i )
    {
        array_t &array = corpus[i];
        array.resize( inArraySize );
        for ( size_t j = 0; j < inArraySize; ++j )
        {
            array[j] = (T)( rand() );
        }
    }

    sw.Stop();
    std::cout << sw.Elapsed() << ” secs” << std::endl;

    std::cout << “scored in … “;
    sw.Start();
    array_t scores( inCorpusSize );
    const array_t &query = corpus[0];
    for ( size_t i = 1; i < inCorpusSize+1; ++i )
    {
        const array_t &array = corpus[i];

        register T &score = scores[i1];
        score = 0;
        for ( size_t j = 0; j < inArraySize; ++j )
        {
            score += array[j]*query[j];
        }
    }

    sw.Stop();
    std::cout << sw.Elapsed() << ” secs” << std::endl;

}

int main( int argc, char **argv )
{
    if ( argc < 2 )
        return 1;

    int csize = atoi(argv[1]);
    int asize = atoi(argv[2]);

    std::cout << “testing float..” << std::endl;
    test<float>( asize, csize );

    std::cout << “testing double..” << std::endl;
    test<double>( asize, csize );

    std::cout << “testing long double..” << std::endl;
    test<long double>( asize, csize );

    std::cout << “testing int..” << std::endl;
    test<int>( asize, csize );

    std::cout << “testing unsigned int..” << std::endl;
    test<unsigned int>( asize, csize );

    std::cout << “testing short..” << std::endl;
    test<short>( asize, csize );

    std::cout << “testing unsigned short..” << std::endl;
    test<unsigned short>( asize, csize );

    std::cout << “testing char..” << std::endl;
    test<char>( asize, csize );

    std::cout << “testing unsigned char..” << std::endl;
    test<unsigned char>( asize, csize );

    std::cout << “testing long long..” << std::endl;
    test<long long>( asize, csize );

    std::cout << “testing unsigned long long..” << std::endl;
    test<unsigned long long>( asize, csize );

    return 0;
}

Syntax highlighting done by: /usr/bin/highlight -O html -t 4 -I -S cpp Main.cpp –inline-css -o /tmp/m.html

The result of running this script with vector size = 100 and corpus size = 1 million is shown below:
sudar@kiriya /opt/testing/bin $ ./tester 1000000 100
testing float..
constructing the corpus…1.447 secs
scored in … 1.731 secs

testing double..
constructing the corpus…1.543 secs
scored in … 1.836 secs

testing long double..
constructing the corpus…2.135 secs
scored in … 2.614 secs

testing int..
constructing the corpus…1.454 secs
scored in … 1.657 secs

testing unsigned int..
constructing the corpus…1.41 secs
scored in … 1.615 secs

testing short..
constructing the corpus…1.394 secs
scored in … 1.59 secs

testing unsigned short..
constructing the corpus…1.347 secs
scored in … 1.542 secs

testing char..
constructing the corpus…1.313 secs
scored in … 1.507 secs

testing unsigned char..
constructing the corpus…1.328 secs
scored in … 1.522 secs

testing long..
constructing the corpus…1.553 secs
scored in … 1.767 secs

testing unsigned long..
constructing the corpus…1.548 secs
scored in … 1.761 secs

  1. If you observe carefully, floating point calculations have taken more time than the fixed point calculations.
  2. Long Double took the longest time and it is the slowest.
  3. The reverse climax is that 64bit fixed calculation is slower than single-precision arithmetic.  An interesting read on multiplication is here.  The reason could be overflow due to the size of product register being 64 bits.
  4. The fastest is 8 bit calculation.  But unsigned 8 bit arithmetic is slower than signed.  Can’t explain why!
  5. For fixed point, unsigned calculations take less time than signed calculations, which can be understood by the additional time taken for 2’s complement arithmetic.
  6. Results can be different with different CPUs / Operating Systems, so infer accordingly.

Upgrade version of the testing application.
#include <vector>
#include <iostream>
#include <cstdlib>
#include “Stopwatch.hpp”
#include <string>
#include <map>

template <typename T>
double test( size_t inArraySize, size_t inCorpusSize )
{
     typedef std::vector<T> array_t;
     typedef std::vector<array_t> arrays_t;

     arrays_t corpus( 2 );
     for ( size_t i = 0; i < 2; ++i )
     {
          array_t &array = corpus[i];
          array.resize( inArraySize );
          for ( size_t j = 0; j < inArraySize; ++j )
          {
               array[j] = (T)( rand()%1000 );
          }
     }

     Stopwatch sw;
     sw.Start();
     const array_t &query = corpus[0];

     array_t scores( inCorpusSize );
     for ( register size_t i = 0; i < inCorpusSize; ++i )
     {
          const array_t &docu = corpus[1];
          T & score = scores[i];
          score = 0;
          for ( register size_t j = 0; j < inArraySize; ++j )
          {
               score += docu[j]*query[j];
          }
     }

     sw.Stop();
     return sw.Elapsed();
}

int main( int argc, char **argv )
{
     typedef double (*fun_t)( size_t, size_t );

     typedef std::pair < std::string, fun_t > named_fun_t;
     std::vector< named_fun_t > functions;

     functions.push_back( named_fun_t( “float”, test<float>) );
     functions.push_back( named_fun_t( “double”, test<double>) );
     functions.push_back( named_fun_t( “long double”, test<long double>) );
     functions.push_back( named_fun_t( “int”, test<int>) );
     functions.push_back( named_fun_t( “unsigned int”, test<unsigned int>) );
     functions.push_back( named_fun_t( “short”, test<short>) );
     functions.push_back( named_fun_t( “unsigned short”, test<unsigned short>) );
     functions.push_back( named_fun_t( “long long”, test<long long>) );
     functions.push_back( named_fun_t( “unsigned long long”, test<unsigned long long>) );
     functions.push_back( named_fun_t( “char”, test<char>) );
     functions.push_back( named_fun_t( “unsigned char”, test<unsigned char>) );

     if ( argc < 4 )
     {
          std::cout << argv[0] << ” <corpus_size> <array_size> <repeats>” << std::endl;
          return 1;
     }

     int csize = atoi(argv[1]);
     int asize = atoi(argv[2]);
     int iters = atoi(argv[3]);

     typedef std::map<std::string, double> timings_t;
     timings_t timings;

     for ( size_t j = 0; j < iters; ++j )
     {
          std::cout << \niteration #” << j+1 << std::endl;
          for ( size_t i = 0; i < functions.size(); ++i )
          {
               std::string name = functions[i].first;
               double timetaken = functions[i].second(asize, csize);

               timings[name] += timetaken;
               std::cout << “testing “ << name << “….” << timetaken << std::endl;
          }
     }

     std::string minstring;
     double minvalue = 99999.9;
     std::cout << \naverages” <<std::endl;
     for ( timings_t::iterator iter = timings.begin(), end = timings.end(); iter != end; ++iter )
     {
          iter->second /= (double)iters;
          std::cout << “average time for “ << iter->first << “: “ << iter->second << std::endl;

          if ( iter->second < minvalue )
          {
               minvalue = iter->second;
               minstring = iter->first;
          }
     }

     std::cout << “minimum timing is for “ << minstring << “: “ << minvalue << std::endl;
}

The result of running this script with vector size = 500 and corpus size = 1 million with 20 iterations is shown below:

iteration #1
testing float….1.473
testing double….1.469
testing long double….2.025
testing int….1.024
testing unsigned int….1.069
testing short….0.996
testing unsigned short….0.993
testing long long….1.004
testing unsigned long long….1.004
testing char….0.991
testing unsigned char….0.991

iteration #2
testing float….1.449
testing double….1.459
testing long double….2.011
testing int….1.002
testing unsigned int….1
testing short….0.985
testing unsigned short….0.99
testing long long….0.993
testing unsigned long long….0.993
testing char….0.983
testing unsigned char….0.992


..
iteration #20
testing float….1.448
testing double….1.45
testing long double….1.975
testing int….0.99
testing unsigned int….0.991
testing short….0.989
testing unsigned short….0.986
testing long long….0.997
testing unsigned long long….0.992
testing char….0.992
testing unsigned char….0.988

averages
average time for char: 0.99575
average time for double: 1.4665
average time for float: 1.4676
average time for int: 1.0046
average time for long double: 2.00115
average time for long long: 1.00585
average time for short: 0.99985
average time for unsigned char: 0.9945
average time for unsigned int: 1.0085
average time for unsigned long long: 1.0025
average time for unsigned short: 0.9963
minimum timing is for unsigned char: 0.9945

So, even in this test, char is the best choice!!

Clicking noise from HDD??

April 22nd, 2013 No comments

Have you wondered replaced your hard drives (HDD), when there is “clicking” noise from the HDD?  When you hear that noise, it means the drive is performing a “hard-reset” internally.   I have always thought that the disk is a goner, when there is too much clicking noise from the HDD.

Lately, it was found that when the gave the HDD the 5 pin power cord, the clicking noise is gone.  In general, 4 pin power has <+12v, 0v, 0v, +5> and the 5 pin power cord has an additional 3.3v orange line.  Another discovery recently is that, the clicking noise is gone when I changed the SMPS.  When the SMPS is over loaded or so, I think it is not able to supply the current that the HDDs want, which in turn makes the HDDs to perform a hard reset internally.

So, before applying for a replacement HDD, please do try changing the power cord to a 5pin cord and when you cannot try replacing the SMPS.  Typically, when you have lot of devices in your machine, ensure you use a reasonably powerful SMPS to avoid outages.

Solar Panels Orientation for Chennai

December 21st, 2012 No comments
    Chennai’s Lat Lon value is 13° 04′ N 80° 17′ E and Earth’s axis is titled by 23.5°, so for Chennai the maximum Sun’s North-South swing angle is 10°N and 36.5°S.  If you setup the solar panel parallel to the ground, you would see the inclination angle of Sun at 12 noon would be a maximum of 10° to the north during Utthrayanam and a maximum of 36.5° to the south during Dakshinayanam.  So, for stationary solar panel fitments, the panel should be oriented to 13.5° to the south to have an uniform Sun’s inclination angle swing (+23.5° to -23.5°) relative to the solar panel reference line.

Understanding a Fan Motor

August 28th, 2012 4 comments
Have you opened up a fan motor before?  It is a simple brush less A/C induction motor, where the armature remains as the stator.  Look at the exploded image of a typical fan motor. The important parts are C: Ball Bearing, D: Stator, E: Armature/Stator, G: Capacitor, H: Connector. 

Also, look at the other image that shows the cross section of a motor.  You would notice that there are 4 wires coming out the motor.  Two pairs of wire, with one pair as the starting coil and the another pair for the running coil.  In general, all single phases induction motors have two coils (starting coil, running coil).  Using a capacitor, an artificial phase difference is created between the fields created by the starting and running coils.  The phase difference triggers movement of the armature.  When the armature reaches a particular speed, using a centrifugal switch, the connection to the starting coil is disconnected and the entire fans runs with just one coil.

Although there are four terminals, you would notice 3 terminals are emitted out, with the starting and running coils connected back-to-back.  Let’s say S1,S2 are the terminals of starting coil and R1,R2 are the terminals of the running coil.  To get 3 terminals out of the fan motor, S2 and R2 are shorted. 

Now, you just see 3 terminals; how do you find which terminal is starting, which one is ending and which one is shorted?  Easy.  Using a simple multimeter, you can find it out.

Let’s say you see terminals A, B, C. Our aim is to find which one of these are S1, R1, S2R2.  Now, let’s measure the resistance between A-B, call it X.  Likewise measure the resistance B-C as Y and A-C as Z.  If you would notice X < Y < Z, you would also notice that Z = Y+X.  Which mean, A-C is action A-B+B-C, that’s why the resistance was additive, also the terminal B is S2R2.  The challenge now is to find what is A and what is C.   As we’d notice A-B=X < B-C=Y, we can confirm that terminal A is starting coil S1 and terminal C is running coil R1.  The reasoning is that; starting coil resistance will be less than running coil resistance.

Hope, this article helped.

Calculating Ampere-Hour AH requirement

May 20th, 2012 No comments
We are in a sorry state of erratic and long power cuts, due to shortage of power production by the nation against the increasing load conditions.  To add fuel to this fire, a wholesome of abled people putting their hard earned money on to power backup solutions, where they store the power during power availability and consume the stored power during outage.  On the whole, this looks simple and elegant, but this is not doing any good to the state, which shed’s power at different locations to balance against shortage in power production.  So theoretically, in a place where a family consumed 1kW per hour, would consume 2.5kW per hour during power availability and generate 1kW during power outage.  Yes, you are right. The equation is not balanced, because atleast 30-50% of power is wasted during the backup-retrieve cycle.

Ok, coming to the point.  What is the solution? Go for harvesting solar power, availability in abundance and omni present.  And most interestingly, rationed to perfection based on the amount of un-shadowed free space a family has.  I will just limit this article to calculating the battery provisioning when you go for a solar-inverter solution.  Let’s say I want to have a power backup for 2 hours and my load is 1kW. What would be the ideal inverter solution for this load condition?

Normal Power 1000 Watts
Power Factor 80 %
Inverter Rating 1000W/80% = 1250 VA
Number of Backup Hours 2 Hours
Energy To be Stored 1000×2=2000Wh
Inverter Battery Voltage 24VDC
Battery Amp-Hours 2000/24=83AH
Add @30% AH Margin 83*1.3=108AH~100AH

So, for this configuration you need a 1250VA Inverter with 2x12v 100Ah battery bank.  Let me explain the calculation,

  1. Power Factor: In AC (alternating current), Power = Voltage x Current x Power factor unlike in DC, Wattage = Voltage x Current.  Power factor is measure as the cosine of the phase angle between voltage waveform and current waveform.  For home use, the power factor will be 0>PF<1.  When PF is lower, the efficiency of the system suffers a lot.
  2. Battery Voltage: For 1250VA inverter system, the choice of battery bank is 24V instead of 12V.  The rationale for this choice is to limit the current from the battery to the inverter unit.  If you use a 12V battery bank, at full load there will be a current of 1250/12=104A flowing from the battery to the inverter.  You may have noticed the thickness of the battery wire be very high.  Despite that the power loss on those wires when the current is 100A, would be much higher than it is with 50A on a 24V system.  For a 24V system, the peak current shall be 1250/24=52A.  Also, at 100A, with 1m cable between battery and inverter, the impedance should be 0.00001 ohms.
  3. AH Margin: Although battery AH rating considers absolutely draining of the battery, we will not be able to do that for normal SMF battery.  Meaning, we should not discharge below 10V and likewise should not charge beyond 13.6V per 12V battery.  In order for the AH rating to work, we have to apply atleast 20-30% margin.

Solar Panel contd.

March 26th, 2012 14 comments

image

image

image

image

image

image

Installation of additional 130Wp is in place now to make the power plant worth 300Wp.  The new panel added has a spec of 17Vmp against the 16.4Vpm of the 170Wp panel group.  So eventually I may be losing some power.  I am using 10sqmm copper cable to reduce the transmission losses.  I had measured the impedance of the cable to 1mΩ. So at 20A, I will be losing about 0.4W only.  But the cost of this wire is around 70Rs/m.  I am able to produce about 221W during the mid day, and about 170W around 10AM.  Upon little bit of investigation, it is found that the solar panels shell out less power at increased temperature.  It is also said that at 60-70°C, the efficiency is around 70%, which is matching with my measurements.  So, thinking about a water cooling solution; basically augmenting a solar water heating solution with the solar panel to establish double benefits.  Every day with the solar panels is a day of new learning and I am enjoying it. 🙂

kDevelop 4.2 Debugging

November 7th, 2011 No comments
    When I was using KDevelop 4.2 for debugging a process, I got perplexed having the inferior application closing down whenever I was setting a breakpoint on the fly.  On the contrary, the breakpoints there were setup before the start of the inferior application, things behave as expected.  With little bit of digging, it is found that whenever a new breakpoint is setup or removed (Toggle Breakpoint), kDevelop inherently issues a SIGINT to the inferior application, which in turn stops the application from debugging.  To handle this problem, setup a signal handler for SIGINT, to consume the Interrupt signal (Ctrl+C, Ctrl+Break).  But once the debugging is over, don’t forget to reset the SIGINT handler.

Hash Overflow due to 64 bit upcasting

October 28th, 2011 No comments
    Lately, I had to debug the following piece of code, where it caused overflow on the hash bucket design.  The code worked perfectly on a Windows machine while compiled for Win32, but failed to work on a Linux Mint x64 machine.  The code is listed below, which basically calculates hash value of an input 32 bit unsigned number, limiting the hash value to 2^10 (1Meg).

hash = ( fpArray*2654404609 )>>12; // Calculate the hash and limit the value to 2^20 (1 Meg)

   When the input value for fpArray was 1724463449 (0x66C93959), the hash value generated was 1779068547 (0x6A0A6E83), which is more than (0x000FFFFF) to cause the hash bucket overflow.

unsigned hash = fpArray * 2654404609;
hash = hash >> 12;

    When I rewrote the code like the above, the value of hash was 2800236889 (0xA6E83959).  Upon shifting right by 12 yields 638651 (0x0009BEBB), which is the correct and expected hash value.

    Overall, the first snippet of code appears to be correct.  Do you see a problem there?  I couldn’t find the issue, until I recalled the 32bit vs 64bit difference.  If you carefully look at the multiplier 2654404609 (0x9E370001), although appears to be a valid 32 bit number, what is the default assignment of type to this number by the compiler?  If it was assigned 64bits, what would happen to the results?  To validate this, I changed the 2nd snippet as the following.

unsigned long hash = (unsigned long)fpArray * 2654404609;
hash = hash >> 12;
unsigned h2 = (unsigned)hash;

    Now, when the input is the same 1724463449 (0x66C93959), the value of hash becomes 4577423727077636441 (0x3F8646A0A6E83959) and upon right shifting by 12 bits yields 1117535089618563 (0x0003F8646A0A6E83). Followed by downcasting to unsigned yield 1779068547 (0x6A0A6E83). Bingo!

    So, what is happening here? While performing (fpArray * 2654404609), the computation is upcasted to 64bit computation by the 64 bit compiler.  So, what is the solution? Just put a “U” at the end of the constant.

hash = ( fpArray*2654404609U )>>12; // Calculate the hash and limit the value to 2^20 (1 Meg)
(or)
const unsigned multipler = 2654404609; // here U suffix is not needed as the constant is explicitly made unsigned
hash = ( fpArray * multiplier ) >> 12;

    Now, the computation will happen with 32 bit numbers to get the expected outputs.

Lessons Learned here:

  1. While using constants, beware of the upcasting and downcasting. So use proper suffixes like U, L, F etc.
  2. Instead of using constants directly in expressions, use them as constant variables.
  3. Be conscious about the compiler type and the assumptions made by the compiler in different build modes.

AWG Vs Current Flow Capacity

September 13th, 2011 No comments

This write up is taken from http://www.engineeringtoolbox.com/wire-gauges-d_419.html

The AWG – American Wire Gauge – is used as a standard method of denoting wire diameter, measuring the diameter of the conductor (the bare wire) with the insulation removed. AWG is sometimes also known as Brown and Sharpe (B&S) Wire Gauge.

The AWG table below is for a single, solid, round conductor. Because of the small gaps between the strands in a stranded wire, a stranded wire with the same current-carrying capacity and electrical resistance as a solid wire, always have a slightly larger overall diameter. The higher the number – the thinner the wire. Typical household wiring is AWG number 12 or 14. For telephone wires there are common with AWG 22, 24, or 26.

AWG Diameter
(mm)
Diameter
(in)
Square
(mm2)
Resistance
(ohm/1000m)
40 0.08 . 0.0050 3420
39 0.09 . 0.0064 2700
38 0.10 0.0040 0.0078 2190
37 0.11 0.0045 0.0095 1810
36 0.13 0.005 0.013 1300
35 0.14 0.0056 0.015 1120
34 0.16 0.0063 0.020 844
33 0.18 0.0071 0.026 676
32 0.20 0.008 0.031 547
30 0.25 0.01 0.049 351
28 0.33 0.013 0.08 232.0
27 0.36 0.018 0.096 178
26 0.41 0.016 0.13 137
25 0.45 0.018 0.16 108
24 0.51 0.02 0.20 87.5
22 0.64 0.025 0.33 51.7
20 0.81 0.032 0.50 34.1
18 1.02 0.04 0.82 21.9
16 1.29 0.051 1.3 13.0
14 1.63 0.064 2.0 8.54
13 1.80 0.072 2.6 6.76
12 2.05 0.081 3.3 5.4
10 2.59 0.10 5.26 3.4
8 3.25 0.13 8.30 2.2
6 4.115 0.17 13.30 1.5
4 5.189 0.20 21.15 0.8
2 6.543 0.26 33.62 0.5
1 7.348 0.29 42.41 0.4
0 8.252 0.33 53.49 0.31
00 (2/0) 9.266 0.37 67.43 0.25
000 (3/0) 10.40 0.41 85.01 0.2
0000 (4/0) 11.684 0.46 107.22 0.16

The higher the gauge number, the smaller the diameter, and the thinner the wire.  Because of less electrical resistance a thick wire will carry more current with less voltage drop than a thin wire. For a long distance it may be necessary to increase the wire diameter – reducing the gauge – to limit the voltage drop.

American Wire Gauge (AWG)
Length
(feet)
Current (amps)
5 10 15 20 25 30 40 50 60 70
15 16 12 10 10 8 8 6 6 4 4
20 14 12 10 8 8 6 6 4 4 4
25 14 10 8 8 6 6 4 4 2 2
30 12 10 8 6 6 4 4 2 2 2
40 12 8 6 6 4 4 2 2 1 1/0
50 10 8 6 4 4 2 2 1 1/0 1/0
60 10 6 6 4 2 2 1 1/0 2/0 2/0
70 10 6 4 2 2 2 1/0 2/0 2/0 3/0
80 8 6 4 2 2 1 1/0 2/0 3/0 3/0
90 8 4 4 2 1 1/0 2/0 3/0 3/0 4/0
Standard Wire Gauge (SWG)

SWG inches mm
7/0 0.500 12.700
6/0 0.464 11.786
5/0 0.432 10.973
4/0 0.400 10.160
3/0 0.372 9.449
2/0 0.348 8.839
1/0 0.324 8.236
1 0.300 7.620
2 0.276 7.010
3 0.252 6.401
4 0.232 5.893
5 0.212 5.385
6 0.192 4.877
7 0.176 4.470
8 0.160 4.064
9 0.144 3.658
10 0.128 3.251
11 0.116 2.946
12 0.104 2.642
13 0.092 2.337
14 0.080 2.032
15 0.072 1.829
16 0.064 1.626
17 0.056 1.422
18 0.048 1.219
19 0.040 1.016
20 0.036 0.914
21 0.032 0.813
22 0.028 0.711
23 0.024 0.610
24 0.022 0.559
25 0.020 0.508
26 0.018 0.457
27 0.0164 0.417
28 0.0148 0.376
29 0.0136 0.345
30 0.0124 0.315
31 0.0116 0.295
32 0.0108 0.274
33 0.0100 0.254
34 0.0092 0.234
35 0.0084 0.213
36 0.0076 0.193
37 0.0068 0.173
38 0.006 0.152
39 0.0052 0.132
40 0.0048 0.122
41 0.0044 0.112
42 0.004 0.102
43 0.0036 0.091
44 0.0032 0.081
45 0.0028 0.071
46 0.0024 0.061
47 0.002 0.051
48 0.0016 0.041
49 0.0012 0.030
50 0.001 0.025

Mother

July 31st, 2011 No comments

தாயின் பெருமைகளை என் தாய் எனக்குச் சொல்ல, இங்கே அதை தொகுத்துள்ளேன்.

  1. தாயில் சிறந்த கோவிலும் இல்லை
  2. தாயின் மடி மீண்டும் அமரமுடியாத சிம்மாசனம்
  3. குழந்தையின் எதிர்காலம் தாயின் கையில்தான் உள்ளது
  4. எல்லோரது இடத்தையும் தாய் வகிக்க முடியும், ஆனால் தாயின் இடத்தை வகிக்க வேறு எவராலும் முடியாது
  5. 1 கோடி போதனையை விட ஒருதுளி தாய்மை மேலானது
  6. மண்ணில் நல்லவனாக வாழவைப்பதும், நானிலத்தில் புகழ் பெற செய்வதும் தாய்தான்
  7. தாயை எதனோடும் ஒப்பிடுதல் கூடாது. ஏனெனில் அவள் ஈடுஇணை அற்றவள்
  8. உலகம் அனைத்தையும் ஒரு தட்டிலும், தாயை ஒரு தட்டிலும் வைத்து தராசில் நிறுத்தால் உலகின் தட்டுதான் மேலே இருக்கும்
  9. தாயின் இதயம்தான் குழந்தைகளின் பள்ளிக்கூடம்
  10. நல்ல தாயை அடைந்தவன் தான் சாதனைகளைப் படைத்து பெரிய மனிதனாக உருவெடுக்கிறான்
  11. தாயின் உள்ளத்தை அறிந்தவன் கடவுளின் கருணையை அறிந்தவன்
  12. வாஞ்சையுள்ள இதயதைப் பெற்றவளே தாயாவாள்
  13. தாயை வணங்குபவனுக்கு தெய்வம் வழிகாட்டும்
  14. தாய் எங்கிருக்கிறாளோ அந்த இடம் சொர்கம்
  15. தாயின் கண்ணீரை துடைப்பவனே சிறந்த மகன்
  16. அன்னைக்கு உதவாதவன் யாருக்கும் உதவாதவன்
  17. அன்னையின் அன்பிற்கு அளவில்லை
  18. தாயை பிரிந்த மகன் வெறும் கூடுதான்