{"id":83,"date":"2020-04-01T13:31:56","date_gmt":"2020-04-01T13:31:56","guid":{"rendered":"https:\/\/temp.ashkerala.com\/?p=83"},"modified":"2020-04-01T13:31:56","modified_gmt":"2020-04-01T13:31:56","slug":"measuring-performance-of-algorithms","status":"publish","type":"post","link":"https:\/\/temp.ashkerala.com\/?p=83","title":{"rendered":"Measuring Performance of Algorithms"},"content":{"rendered":"

There are two aspects <\/em>of algorithmic performance:<\/strong><\/p>\n

Time<\/strong><\/p>\n

– Instructions take time.<\/p>\n

– How fast does the algorithm perform?<\/p>\n

– What affects its runtime?<\/p>\n

Space<\/strong><\/p>\n

– Data structures take\u00a0\u00a0\u00a0 space<\/p>\n

– What kind of data structures can be used?<\/p>\n

–\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 How does choice of data structure affect the runtime?<\/p>\n

Algorithms can not be compared by running them on computers. Run time is system dependent.<\/p>\n

Even on same computer would depend on language<\/p>\n

Real time units like microseconds not to be used.<\/p>\n

Generally concerned with how the amount of work varies with the data.<\/p>\n

Measuring\u00a0 Time Complexity<\/strong><\/p>\n

Counting\u00a0 number of operations\u00a0 involved in the algorithms to handle\u00a0 n items.<\/p>\n

Meaningful comparison for very large values of\u00a0\u00a0 n.<\/p>\n

Complexity of Linear Search<\/strong><\/p>\n

Consider the task of searching a list to see if it contains a particular value.<\/p>\n

\u0393\u00c7\u00f3 A useful search algorithm should be general.<\/em><\/p>\n

\u0393\u00c7\u00f3 Work done varies with the size of the list<\/p>\n

\u0393\u00c7\u00f3 What can we say about the work done for list of any <\/em>length?<\/p>\n

i = 0;<\/p>\n

while (i < MAX && this_array[i] != target)<\/p>\n

\u00a0\u00a0\u00a0 \u00a0i = i + 1;<\/p>\n

if (i <MAX)\u00a0<\/p>\n

\u00a0\u00a0\u00a0 printf ( \u0393\u00c7\u00a3Yes, target is there \\n\u0393\u00c7\u00a5 );<\/p>\n

else<\/p>\n

\u00a0\u00a0\u00a0 printf( \u0393\u00c7\u00a3No, target isn\u0393\u00c7\u00d6t there \\n\u0393\u00c7\u00a5 );<\/p>\n

\u00a0The work involved :\u00a0 Checking target value with each of the n elements.<\/p>\n

\u00a0no. of operations:\u00a0\u00a0 \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 1 \u00a0\u00a0\u00a0\u00a0 \u00a0(best case)<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 (worst case)<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 n\/2\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 (average case)<\/p>\n

Computer scientists tend to\u00a0 be concerned about the<\/p>\n

\u00a0Worst Case complexity<\/em>.<\/strong><\/p>\n

\u00a0The worst case guarantees that the performance of the algorithm will be at least as good as the analysis indicates.<\/p>\n

Average Case Complexity:<\/em><\/strong><\/p>\n

It is the best statistical estimate of actual performance, and tells us how well an algorithm performs if you average the behavior over all possible sets of input data. However, it requires considerable mathematical sophistication\u00a0 to do the average case analysis.<\/p>\n

Algorithm Analysis: Loops<\/strong><\/p>\n

Consider\u00a0\u00a0 an\u00a0 n X n\u00a0 two dimensional array. Write a loop to store the row sums in a one-dimensional array rowsand the overall total in grandTotal.<\/p>\n

\n

LOOP 1:<\/strong><\/p>\n<\/div>\n

grandTotal = 0;<\/p>\n

for (k=0; k<n-1; ++k)\u00a0 {<\/p>\n

rows[k] = 0;<\/p>\n

for (j = 0; j <n-1; ++j){<\/p>\n

rows[k] = rows[k] + matrix[k][j];<\/p>\n

grandTotal = grandTotal + matrix[k][j];<\/p>\n

}<\/p>\n

}<\/p>\n

\u00a0It takes 2n2\u00a0 <\/sup>addition operations<\/p>\n

\n

LOOP 2:<\/strong><\/p>\n<\/div>\n

grandTotal =0;<\/p>\n

for (k=0; k<n-1; ++k)<\/p>\n

rows[k] = 0;<\/p>\n

for (j = 0; j <n-1; ++j)<\/p>\n

rows[k] = rows[k] + matrix[k][j];<\/p>\n

grandTotal = grandTotal + rows[k];<\/p>\n

}<\/p>\n

This one takesn2<\/sup>+ n\u00a0 operations<\/p>\n

Big-O Notation<\/strong><\/p>\n

We want to understand how the performance of an algorithm responds to changes in problem size. Basically the goal is to provide a qualitative<\/em> insight. The Big-O notation is a way of measuring the order of magnitude of a mathematical expression<\/p>\n

\u00a0O(n)\u00a0 means on the Order of n<\/p>\n

Consider<\/strong><\/em><\/p>\n

n4<\/sup> + 31<\/sub>n2<\/sup> + 10\u00a0\u00a0 = f (n)<\/em><\/p>\n

The idea is to reduce the formula in the parentheses so that it captures the qualitative behavior in simplest possible terms. We eliminate any term whose contribution to the total ceases to be significant as\u00a0\u00a0 n\u00a0 becomes large.<\/p>\n

We also eliminate any constant factors, as these have no effect on the overall pattern\u00a0\u00a0 as\u00a0 n\u00a0 increases.\u00a0 Thus we may approximate f(n) above as<\/p>\n

O (n4<\/sup> + 31<\/sub>n2<\/sup> + 10) = O(\u00a0 n4)<\/sup><\/em><\/p>\n

\u00a0Let g(n)\u00a0 =\u00a0 n4<\/sup><\/em><\/p>\n

Then the order of f(n) is O[g(n)].\u00a0<\/p>\n

Definition:<\/strong>f(n)\u00a0 is O(g(n)) if there exist positive numbers c and N such that\u00a0 f(n) < = c g(n) for all\u00a0 n >=N.<\/p>\n

\u00a0i.e.\u00a0 f\u00a0 is big \u0393\u00c7\u00f4O of\u00a0 g\u00a0\u00a0 if there is\u00a0\u00a0 c such that\u00a0\u00a0 f\u00a0 is not larger than\u00a0 cg\u00a0 for sufficiently large\u00a0\u00a0 value of n ( greater than N)<\/p>\n

c g(n) is an upper bound on the value of\u00a0 f(n)<\/p>\n

That is, the number of operations is at worst proportional to g(n)<\/em> for all large values of n<\/em>.<\/p>\n

How does one determine\u00a0 c and N?<\/p>\n

Let f(n) = 2 n2<\/sup> + 3n + 1\u00a0\u00a0 = O (n2<\/sup><\/em> )<\/p>\n

Now\u00a0 2 n2<\/sup> + 3n + 1\u00a0 < = c n2<\/sup><\/em><\/p>\n

Or\u00a0 2 +\u00a0 (3\/n) + ( 1 \/ n2<\/sup><\/em>\u00a0\u00a0 )\u00a0 < = c<\/p>\n

You\u00a0 want to find c such that a term in\u00a0 f\u00a0 becomes the largest and stays the largest.\u00a0 Compare first and second term. First will overtake the second at\u00a0 N = 2,<\/p>\n

so for N= 2, c >= 3.75,<\/p>\n

for N = 5,\u00a0\u00a0 c >= slightly more than 2,\u00a0<\/p>\n

for very large value of n, c is almost 2.<\/p>\n

g is\u00a0 almost always > = f\u00a0 if it is multiplied by a constant c<\/p>\n

Look at it another way : suppose you\u00a0 want to find weight of\u00a0 elephants, cats and ants in a jungle. Now irrespective of how many of each item were there, the net weight would be proportional to the weight of an elephant.<\/p>\n

Incidentally we can also say\u00a0 f\u00a0 is big -O not only of\u00a0\u00a0\u00a0 n2<\/sup><\/em> but also of n3<\/sup><\/em>\u00a0\u00a0 , n4<\/sup><\/em>\u00a0\u00a0\u00a0 , n5<\/sup><\/em>\u00a0\u00a0 etc\u00a0 (HOW ?)<\/p>\n

\u252c\u00a1\u00a0 Loop 1 and Loop 2 are both in the same big-O category: O(n2<\/sup>)<\/p>\n

\u00a0Properties of Big-O notation:<\/strong><\/p>\n

O(n)\u00a0 + O(m)\u00a0 = O(n) if\u00a0 n > = m<\/p>\n

The function log n to base a is\u00a0 order of O( log n to base b)<\/p>\n

For any values of a and b\u00a0 ( you can show that any\u00a0 log values are multiples of each other)<\/p>\n

Linear search Algorithm:<\/strong><\/p>\n

Best Case<\/strong>– It\u0393\u00c7\u00d6s the first value<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \u0393\u00c7\u00a3order 1,\u0393\u00c7\u00a5 O(1)<\/p>\n

Worst Case<\/strong>– It\u0393\u00c7\u00d6s the last value, n<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \u0393\u00c7\u00a3order n,\u0393\u00c7\u00a5 O(n)<\/p>\n

Average<\/strong>– N\/2 (if value is present)<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \u0393\u00c7\u00a3order n,\u0393\u00c7\u00a5 O(n)<\/p>\n

Example 1:<\/strong><\/p>\n

Use big-O notation to analyze the time efficiency of the following fragment of C code:<\/p>\n

for(k = 1; k <= n\/2; k++) <\/strong><\/p>\n

{<\/strong><\/p>\n

\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

\u00a0\u00a0\u00a0 for (j = 1; j <= n*n; j++)<\/strong><\/p>\n

\u00a0\u00a0\u00a0 {<\/strong><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

\u00a0\u00a0\u00a0 }<\/strong><\/p>\n

}<\/strong><\/p>\n

Since these loops are nested, the efficiency is n3<\/sup>\/2<\/em>, or O(n3<\/sup><\/em>) in big-O terms.<\/p>\n

Thus, for two loops with O[f1<\/sub>(n)<\/em>] and O[f2<\/sub>(n)<\/em>] efficiencies, the efficiency of the nesting of these two loops is<\/p>\n

O[f1<\/sub>(n) * f2<\/sub>(n)<\/em>].<\/p>\n

Example 2:<\/strong><\/p>\n

Use big-O notation to analyze the time efficiency of the following fragment of C code:<\/p>\n

for (k=1; k<=n\/2; k++)<\/strong><\/p>\n

{<\/strong><\/p>\n

\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

}<\/strong><\/p>\n

for (j = 1; j <= n*n; j++)<\/strong><\/p>\n

{<\/strong><\/p>\n

\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

\u00a0\u00a0\u00a0 .<\/strong><\/p>\n

}<\/strong><\/p>\n

The number of operations executed by these loops is the sum of the individual loop efficiencies. Hence, the efficiency is n\/2+n2<\/sup><\/em>, or O(n2<\/sup><\/em>) in big-O terms.<\/p>\n

Thus, for two loops with O[f1<\/sub>(n)<\/em>] and O[f2<\/sub>(n)<\/em>] efficiencies, the efficiency of the sequencing of these two loops is<\/p>\n

O[fD<\/sub>(n)<\/em>] where fD<\/sub>(n) <\/em>is the dominant of the functions f1<\/sub>(n) <\/em>and f2<\/sub>(n)<\/em>.<\/p>\n

Complexity of Linear Search<\/strong><\/p>\n

In measuring performance, we are generally concerned with how the amount of work varies with the data. Consider, for example, the task of searching a list to see if it contains a particular value.<\/p>\n

\u0393\u00c7\u00f3 A useful search algorithm should be general.<\/em><\/p>\n

\u0393\u00c7\u00f3 Work done varies with the size of the list<\/p>\n

\u0393\u00c7\u00f3 What can we say about the work done for list of any <\/em>length?<\/p>\n

i = 0;<\/p>\n

while (i < MAX && this_array[i] != target)<\/p>\n

\u00a0\u00a0\u00a0 \u00a0i = i + 1;<\/p>\n

if (i <MAX)\u00a0<\/p>\n

\u00a0\u00a0\u00a0 printf ( \u0393\u00c7\u00a3Yes, target is there \\n\u0393\u00c7\u00a5 );<\/p>\n

else<\/p>\n

\u00a0\u00a0\u00a0 printf( \u0393\u00c7\u00a3No, target isn\u0393\u00c7\u00d6t there \\n\u0393\u00c7\u00a5 );<\/p>\n

\u00a0<\/p>\n

Order Notation<\/strong><\/p>\n

How much work to find the target in a list containing N elements?<\/p>\n

Note<\/em>: we care here only about the growth rate <\/em>of work. Thus, we toss out all constant values<\/em>.<\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Best Case work is constant<\/em>; it does not grow with the size of the list.<\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Worst and Average Cases work is proportional <\/em>to the size of the list, N.<\/p>\n

\u00a0<\/p>\n

\u00a0Order Notation<\/strong><\/p>\n

O(1) or \u0393\u00c7\u00a3Order One\u0393\u00c7\u00a5: Constant time<\/em><\/strong><\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 does not <\/em>mean that it takes only one operation<\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 does <\/em>mean that the work doesn\u0393\u00c7\u00d6t change <\/em>as N changes<\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 is a notation for \u0393\u00c7\u00a3constant work\u0393\u00c7\u00a5<\/em><\/p>\n

O(n) or \u0393\u00c7\u00a3Order n\u0393\u00c7\u00a5: Linear time<\/em><\/strong><\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 does not <\/em>mean that it takes N operations<\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 does <\/em>mean that the work changes in a way that is\u00a0 proportional <\/em>to N<\/p>\n

\u252c\u2556\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 is a notation for \u0393\u00c7\u00a3work grows at a linear rate<\/em>\u0393\u00c7\u00a5<\/p>\n

\u00a0O(n2<\/sup><\/em>)\u00a0 or \u00a0\u0393\u00c7\u00a3Order n2<\/sup> \u0393\u00c7\u00a5: Quadratic time<\/em><\/strong><\/p>\n

O(n3<\/sup><\/em>)\u00a0 or \u00a0\u0393\u00c7\u00a3Order n3<\/sup> \u0393\u00c7\u00a5: Cubic time<\/em><\/strong><\/p>\n

Algorithms whose efficiency can be expressed in terms of a polynomial of the form<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 am<\/sub>nm<\/sup> + am-1<\/sub>nm-1<\/sup> + … + a2<\/sub>n2<\/sup> + a1<\/sub>n + a0<\/sub><\/em><\/p>\n

are called polynomial algorithms<\/em><\/strong>.\u00a0 Order\u00a0 O(nm<\/sup><\/em>).<\/strong><\/p>\n

Some algorithms even take less time than the number of elements in the problem. There is a notion of\u00a0 logarithmic time algorithms.\u00a0<\/p>\n

We know\u00a0 103<\/sup>\u00a0 =1000 <\/em><\/p>\n

So we can write it as log10<\/sub>1000\u00a0 = 3<\/em><\/p>\n

Similarly suppose we have<\/p>\n

26<\/sup>\u00a0 =64<\/em><\/p>\n

then we can write<\/p>\n

log2<\/sub>64\u00a0 = 6<\/em><\/p>\n

If\u00a0 the work of an algorithm can be reduced by half in one step, and in k steps we are able to solve the problem then<\/p>\n

2k<\/sup>\u00a0 =\u00a0 n<\/em><\/p>\n

or in other words<\/p>\n

log2<\/sub>n\u00a0 = k<\/em><\/p>\n

This algorithm will be having a logarithmic time<\/strong> complexity ,usually written as\u00a0 O(ln n).<\/strong><\/p>\n

Because loga<\/sub>n<\/em> will increase much more slowly than n<\/em> itself, logarithmic algorithms are generally very efficient. It also can be shown that it\u00a0 does not matter as to what base value is chosen.<\/p>\n

Example 3:<\/strong><\/p>\n

Use big-O notation to analyze the time efficiency of the following fragment of C code:<\/p>\n

k = n;<\/strong><\/p>\n

while (k > 1)<\/strong><\/p>\n

{<\/strong><\/p>\n

.<\/strong><\/p>\n

.<\/strong><\/p>\n

k = k\/2;<\/strong><\/p>\n

}<\/strong><\/p>\n

Since the loop variable is cut in half each time through the loop, the number of times the statements inside the loop will be executed is log2<\/sub>n.<\/p>\n

Thus, an algorithm that halves the data remaining to be processed on each iteration of a loop will be an O(log2<\/sub>n<\/em>) algorithm.<\/p>\n

There are a large number of algorithms whose complexity is O( n log2<\/sub>n<\/em>) . <\/strong><\/p>\n

Finally there are algorithms whose efficiency is dominated by a term of the form an<\/sup><\/em><\/strong><\/p>\n

These are called exponential algorithms<\/em><\/strong>. They are of more theoretical rather than practical interest because they cannot reasonably run on typical computers for moderate values of n<\/em>.\u00a0\u00a0<\/p>\n

\u00a0<\/p>\n

Comparison of N<\/em>, logN <\/em>and N2<\/sup><\/em><\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
\n

N<\/strong><\/p>\n<\/td>\n

\n

O(LogN)<\/strong><\/p>\n<\/td>\n

\n

O(N2<\/sup>)<\/strong><\/p>\n<\/td>\n<\/tr>\n

\n

16<\/p>\n<\/td>\n

\n

4<\/p>\n<\/td>\n

\n

256<\/p>\n<\/td>\n<\/tr>\n

\n

64<\/p>\n<\/td>\n

\n

6<\/p>\n<\/td>\n

\n

4K<\/p>\n<\/td>\n<\/tr>\n

\n

256<\/p>\n<\/td>\n

\n

8<\/p>\n<\/td>\n

\n

64K<\/p>\n<\/td>\n<\/tr>\n

\n

1,024<\/p>\n<\/td>\n

\n

10<\/p>\n<\/td>\n

\n

1M<\/p>\n<\/td>\n<\/tr>\n

\n

16,384<\/p>\n<\/td>\n

\n

14<\/p>\n<\/td>\n

\n

256M<\/p>\n<\/td>\n<\/tr>\n

\n

131,072<\/p>\n<\/td>\n

\n

17<\/p>\n<\/td>\n

\n

16G<\/p>\n<\/td>\n<\/tr>\n

\n

262,144<\/p>\n<\/td>\n

\n

18<\/p>\n<\/td>\n

\n

6.87E+10<\/p>\n<\/td>\n<\/tr>\n

\n

524,288<\/p>\n<\/td>\n

\n

19<\/p>\n<\/td>\n

\n

2.74E+11<\/p>\n<\/td>\n<\/tr>\n

\n

1,048,576<\/p>\n<\/td>\n

\n

20<\/p>\n<\/td>\n

\n

1.09E+12<\/p>\n<\/td>\n<\/tr>\n

\n

1,073,741,824<\/p>\n<\/td>\n

\n

30<\/p>\n<\/td>\n

\n

\u00a01.15E+18<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\u00a0<\/p>\n","protected":false},"excerpt":{"rendered":"

There are two aspects of algorithmic performance: Time – Instructions take time. – How fast does the algorithm perform? – What affects its runtime? Space – Data structures take\u00a0\u00a0\u00a0 space – What kind of data structures can be used? –\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 How does choice of data structure affect the runtime? Algorithms can not be compared by…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"footnotes":""},"categories":[8],"tags":[],"class_list":["post-83","post","type-post","status-publish","format-standard","hentry","category-ugc-research"],"_links":{"self":[{"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=\/wp\/v2\/posts\/83","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=83"}],"version-history":[{"count":0,"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=\/wp\/v2\/posts\/83\/revisions"}],"wp:attachment":[{"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=83"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=83"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/temp.ashkerala.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=83"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}