#optimalization

[aneboo-cz-blog]

Today we created a short movie with our services! Enjoy it 😉 #videoanimation#afterefects#video#videoproduction#short#finally#today#is#great#day#our#services#business#solution#car#van#graphic#designs#designstudio#graphicdesign#webdesign#web#website#seo#social#advertisement#media#online#marketing#optimalization#hard#workinghard#creative#agency#better#successful#enjoy#funny (v místě Aneboo.cz)

[toppozicie]

Ako zlepšiť pozície webstránky vo výsledkoch vyhľadávania Google

Získajte návod ako zlepšiť pozície webstránky vo výsledkoch vyhľadávania v Google. Aby bol váš web vyššie vo výsledkoch vyhľadávania v Googl

[reliasolde]

What is process optimization in manufacturing and production? Why is it important, and what are the benefits? Check the information on our blog!

Process optimization, i.e. necessity or trend?

No matter what, your processes should always run at peak efficiency. Productivity has a direct impact on the productivity of the workers who use these processes. Think about it. What if an employee has a defective device and it takes two days for the IT team to respond? The employee is forced not to work all the time. Companies that have been around for a while don't have the ability to scrape everything off and rebuild their processes from scratch.

These companies refine detailed processes the first time and apply them over a long period of time

The easiest and best option is to continuously optimize your processes. Process optimization is the discipline of adjusting a process to optimize a specific set of parameters without violating a few limitations. The most common goals are to minimize costs and maximize throughput and / or efficiency. It is one of the main quantitative tools in industrial decision making. Business process optimization is the practice of increasing the efficiency of an organization through process improvement. It is part of the business process management (BPM) discipline. Optimized processes lead to optimized business goals.

https://reliasol.ai/process-optimization-fashion-or-essential/

[brinckengyuri-blog]

Need for speed: loop optimalisation

I like these part from the  Monty Python film Monty Python and the Holy Grail: “A Reading from the Book of Armaments, Chapter 4, Verses 16 to 20: Then did he raise on high the Holy Hand Grenade of Antioch, saying, "Bless this, O Lord, that with it thou mayst blow thine enemies to tiny bits, in thy mercy." And the people did rejoice and did feast upon the lambs and toads and tree-sloths and fruit-bats and orangutans and breakfast cereals ... Now did the Lord say, "First thou pullest the Holy Pin. Then thou must count to three. Three shall be the number of the counting and the number of the counting shall be three. Four shalt thou not count, neither shalt thou count two, excepting that thou then proceedeth to three. Five is right out. Once the number three, being the number of the counting, be reached, then lobbest thou the Holy Hand Grenade in the direction of thine foe, who, being naughty in my sight, shall snuff it." King Arthur: Right. One... two... five. Galahad: Three, sir. King Arthur: Three.“ If you like to optimize your code, you will found articles about the differences between the

++variable;

and

variable++;

. But I like to know which is the difference (if exist) between this loops:

count from zero to integer

and

count from integer to zero For a first sight I don`t found too big differences but maybe.... I wrote one easy code in C with different types of the looping but the cores inside the loops was similar; do something because if the loop core is empty, then some optimizing function can drop the whole loop. In these cases the core inside the loops run with time O (ordo) every time, the only important differences are the comparisons in the third parameters of the for command. fortest.c:

#include <stdio.h> #include <time.h> #include <sys/time.h> #include <time.h>

#define timersub(a, b, result)  do {        \            (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;       \            (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;        \            if ((result)->tv_usec < 0) {    --(result)->tv_sec;     (result)->tv_usec += 1000000;   }       \    } while  (0);

void test1(unsigned long limit) { int x=0;unsigned long d;        for (d=0 ; d !=limit; ++d)        {      ++x;    if (x<0) {  return ; }} } void test2(unsigned long limit) {int x=0;unsigned long d;        for (d=0; d < limit; ++d) {      ++x;    if (x<0) {  return ; }} } void test3(unsigned long limit) {int x=0;unsigned long d;        for (d= limit; d != 0; --d) {      ++x;    if (x<0) {return ;}} } void test4(unsigned long limit) {int x=0;unsigned long d;        for (d= limit; d > 0; --d)  {   ++x;    if (x<0) {  return ; }} } void test11(unsigned long limit) { int x=0;unsigned long d;        for (d=0 ; d !=limit; ++d)        {      ++x;    if (x==0) {  return ; }} } void test12(unsigned long limit) {int x=0;unsigned long d;        for (d=0; d < limit; ++d) {      ++x;    if (x==0) {  return ; }} } void test13(unsigned long limit) {int x=0;unsigned long d;        for (d= limit; d != 0; --d) {      ++x;    if (x==0) {return ;}} } void test14(unsigned long limit) {int x=0;unsigned long d;        for (d= limit; d > 0; --d)  {   ++x;    if (x==0) {  return ; }} }

void main () {    struct timeval t1,t2,t3,t4,t5,t6,t7,t21,t32,t43,t54,t65,t76;    int x;    unsigned long limit = 300000000;    for (int a=30; a!=0; --a) {        gettimeofday(&t1, NULL);        test1(limit);           gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test2(limit);           gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test3(limit);           gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test4(limit);           gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test11(limit);          gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test12(limit);          gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test13(limit);          gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        gettimeofday(&t1, NULL);        test14(limit);          gettimeofday(&t2, NULL);        timersub(&t2, &t1, &t21);    printf("%ld.%06ld\t", (long int)t21.tv_sec, (long int)t21.tv_usec);        printf("\n");    } }

After the compilation ( gcc -std=c99 -o fortest ./fortest.c ) I ran the program (DELL notebook with Intel COREi5, Debian, 8G ram , nothing interesting) here is the result:

./fortest 0.819198 0.723209 0.547804 0.548121 0.715225 0.739564 0.548305 0.548662 0.749286 0.729770 0.548365 0.547611 0.716539 0.742632 0.547106 0.551919 0.749886 0.719612 0.548613 0.547090 0.717064 0.742903 0.547392 0.550720 0.750686 0.726905 0.549612 0.548379 0.719603 0.740837 0.547805 0.551163 0.750537 0.723098 0.549605 0.548025 0.718798 0.740684 0.548263 0.549131 0.752201 0.731910 0.547758 0.548353 0.728089 0.739966 0.548394 0.549994 0.747660 0.725875 0.547534 0.547997 0.721134 0.737523 0.557083 0.548719 0.746503 0.719368 0.547573 0.548859 0.724068 0.739599 0.548079 0.551764 0.745228 0.725389 0.547391 0.548952 0.717829 0.738182 0.547810 0.551259 0.749495 0.723209 0.548815 0.547587 0.716831 0.739543 0.547409 0.551856 . .

I had some conception about the result but the was a big surprise for me:

The differences between the comparisons are very significant!

The speed of the comparisons in C (from fastest to slowers):

variable != 0

variable > 0

variable < limit

variable != limit

The difference is up to ~40 percent.....

The origin of the differences came from the cpu code: when the cpu want compare the variable with the limit then they need access the ram (I know: the cache) but the comparison with the zero not. I compiled without any compiler-level speed optimization. If I have some time then I rewrite and rerun the code in Java, Javascript, Ada, Pascal, basic, BASH, Perl, php, python, (Excell macro???) and I will update this. This is more interesting what I thought :D

[czytelnia]

[pavolsatala-blog]

Achieving amazing graphics performance

<![CDATA[// <![CDATA[ // <![CDATA[ (function(d, s, id) { var js, fjs = d.getElementsByTagName(s)[0]; if (d.getElementById(id)) {return;} js = d.createElement(s); js.id = id; js.src = "//connect.facebook.net/en_US/all.js#xfbml=1"; fjs.parentNode.insertBefore(js, fjs); }(document, 'script', 'facebook-jssdk')); // ]]<![CDATA[> // ]]]]><![CDATA[>]]>

One important rule to achieve smooth graphics in our applications is: No calculations and objects creating in onDraw functions.  On iOS may run onDraw functions up to 60 times per second. Thanks to high FPS, optimization of this function is very important.

Every calculation and creating new objects in drawing functions slows this function.

Non-optimalized function may contain a lot of operations, which causes that this function runs too long.

I have created two sample applications. First, non-optimalized, contains lots of calculations and object

creating. These operations take too much time to run in onDraw function. This sample codes uses Moscrif SDK.

Non-optimized function:

...= function(sender, canvas) { //create objects var textPaint = new Paint(); textPaint.color = 0xff7DFAFF; textPaint.typeface = Typeface.fromName("36 days ago BRK"); textPaint.textSize = System.width / 10;   var paint = new Paint(); paint.color = 0xffffffff; //vector drawing app.drawCenteredPath(canvas, app.icons[#menuShadow], paint, sender, 0, sender.height/2 -  sender.height/4 + 2, System.width );

//create shader var start = { ... } var end = { ... }; ... var clrs = new Array(); ... var pos = new Array(); ... var shader = Shader.linear(pts, clrs, pos,0); paint.shader = shader; //native drawing canvas.drawRect(0, 0, System.width, sender.height - sender.height/4, paint); //calculations var textAreaHeight = sender.height - sender.height/4; //time string creating var timeString = sender.time / 60 + ":" + sender.time%60; var (w, h) = textPaint.measureText(timeString); canvas.drawText(timeString, sender.width / 2 - w / 2, textAreaHeight / 3 + h / 2, textPaint); }

  Optimized function:

function drawMenu(sender, canvas) { this.paint.color = 0xffffffff;

canvas.drawPath(this.whitePath, this.paint);

//draw rect filled with gradient canvas.drawRect(0, 0, System.width, sender.height - sender.height/4, this.shaderPaint);

//draw vector path of menu graphics canvas.drawPath(this.blackPath, this.shaderPaint); canvas.drawText(this._timeString, sender.width / 2 - this.timeWidth / 2, sender.height / 4 + this.timeHeight / 2, this.timePaint); canvas.drawText(this._text, sender.width / 2 - this.textWidth / 2, sender.height / 2 + this.timeHeight / 2, this.textPaint); }

As you can see optimized function calls only methods from native canvas object. Thanks to the hardware graphics accelerator on devices are these calls extremely fast. Optimized function runs fast and reliable. Optimized function also requires less processor performance, what means that battery life is also longer.

Thanks to this type of optimization your applications will able to achive heigh avarage FPS and draw smooth graphics.