{"id":11324,"date":"2024-05-25T11:51:21","date_gmt":"2024-05-25T15:51:21","guid":{"rendered":"https:\/\/blogs.mathworks.com\/cleve\/?p=11324"},"modified":"2024-05-25T11:51:21","modified_gmt":"2024-05-25T15:51:21","slug":"ibm-hexadecimal-floating-point","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/cleve\/2024\/05\/25\/ibm-hexadecimal-floating-point\/","title":{"rendered":"IBM Hexadecimal Floating Point"},"content":{"rendered":"<div class=\"content\"><!--introduction-->\r\n<p>Our technical support group recently received a request for a tool that would convert IBM System\/360 hexadecimal floating point numbers to the IEEE-754 format. I am probably the only one left at MathWorks that actually used IBM mainframe computers. I thought we had seen the last of hexadecimal arithmetic years ago. But, it turns out that the hexadecimal floating point format is alive and well.<\/p>\r\n<!--\/introduction-->\r\n<h3>Contents<\/h3>\r\n<div>\r\n<ul>\r\n<li>\r\n<a href=\"#927291b6-bb83-4c85-937c-8f20844b3c74\">IBM System\/360<\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#43cbbb43-f2f5-4415-99df-f6a6c114c912\">Formats<\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#5d482994-2d0d-42fa-86e2-c98bc728ebbe\">Data<\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#099df223-ed1e-405e-917f-0cccd1d54a26\"><tt>Hex_ieee<\/tt><\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#126c1d80-75f5-4879-841f-de925f083fc1\"><tt>ieee2ibm<\/tt><\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#88d3bc9c-b626-4578-872e-b95f02057e43\"><tt>ibm2ieee<\/tt><\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#64f8c2ec-011c-40a2-a2f3-a2926ee929ac\">Examples<\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#41ed0fce-64bf-4471-b2c3-e22645d184f5\">Comparison<\/a>\r\n<\/li>\r\n<li>\r\n<a href=\"#9e4ce83f-58b7-498d-b480-9f17c5c1f6e0\">Software<\/a>\r\n<\/li>\r\n<\/ul>\r\n<\/div>\r\n<h4>IBM System\/360<a name=\"927291b6-bb83-4c85-937c-8f20844b3c74\"><\/a>\r\n<\/h4>\r\n<p>The System\/360 is a family of mainframe computers that IBM introduced in 1965 and that dominated the computer industry until PCs came along twenty years later. They range in size from desk-sized to systems that fill a large room.<\/p>\r\n<p>Here is a photo of a mid-sized model.<\/p>\r\n<p>\r\n<img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/blogs.mathworks.com\/cleve\/files\/ibm-360-60.png\" alt=\"\"> <\/p>\r\n<p>\r\n<i>System\/360, Model 60.<\/i> <i>Photo from Ken Shirrif's blog, IBM 360\/System Summary<\/i>.<\/p>\r\n<p>The System\/360 architecture is byte-oriented, so it can handle business data processing as well as scientific and engineering computation. This leads to base-16, rather than base-2 or base-10, floating point arithmetic.<\/p>\r\n<pre>* Binary      f*2^e    1\/2&lt;=f&lt;1\r\n* Decimal     f*10^e   1\/10&lt;=f&lt;1\r\n* Hexadecimal f*16^e   1\/16&lt;=f&lt;1<\/pre>\r\n<h4>Formats<a name=\"43cbbb43-f2f5-4415-99df-f6a6c114c912\"><\/a>\r\n<\/h4>\r\n<p>Floating point formats played an important role in technical computing in the early days. This table from <a href=\"https:\/\/www.amazon.com\/exec\/obidos\/ASIN\/0131653326\/acmorg-20\">FMM<\/a> lists formats that were in use in the 1970s, before IEEE-754 was introduced in 1985.<\/p>\r\n<p>\r\n<img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/blogs.mathworks.com\/cleve\/files\/fmm2.png\" alt=\"\"> <\/p>\r\n<h4>Data<a name=\"5d482994-2d0d-42fa-86e2-c98bc728ebbe\"><\/a>\r\n<\/h4>\r\n<p>The System\/360 hexadecimal format is used in many industries for the preservation of data files.<\/p>\r\n<p>\r\n<a href=\"https:\/\/www.crewes.org\/ResearchLinks\/FreeSoftware\">CREWES<\/a>. Teaching exploration seismology. Comprehensive MATLAB toolbox for use with the textbook \"Numerical Methods of Exploration Seismology with algorithms in Matlab\" by Gary F. Margrave, a geoscience professor at the University of Calgary.<\/p>\r\n<p>\r\n<a href=\"https:\/\/www.loc.gov\/preservation\/digital\/formats\/fdd\/fdd000464.shtml\">Library of Congress<\/a>. Government.<\/p>\r\n<p>\r\n<a href=\"https:\/\/nssdc.gsfc.nasa.gov\/nssdc\/formats\/IBM_32-Bit.html\">NASA<\/a>. Astronautics.<\/p>\r\n<p>\r\n<a href=\"https:\/\/support.sas.com\/content\/dam\/SAS\/support\/en\/technical-papers\/record-layout-of-a-sas-version-5-or-6-data-set-in-sas-transport-xport-format.pdf\">SAS<\/a>. Statistics and business analytics. SAS wrapers for C.<\/p>\r\n<p>\r\n<a href=\"https:\/\/github.com\/enthought\/ibm2ieee\">Enthought<\/a>. Python wrappers for C.<\/p>\r\n<h4>\r\n<tt>Hex_ieee<\/tt><a name=\"099df223-ed1e-405e-917f-0cccd1d54a26\"><\/a>\r\n<\/h4>\r\n<p> <a href=\"https:\/\/blogs.mathworks.com\/cleve\/files\/Hex_ieee.m\"><tt>Hex_ieee<\/tt><\/a>. I have two twenty-line MATLAB functions, <tt>ieee2ibm<\/tt> and <tt>ibm2ieee<\/tt>, that convert IEEE-754 floating point to and from IBM hexadecimal format.<\/p>\r\n<p>Three statements in the middle of <tt>ieee2ibm<\/tt> are the key to the entire operation. The first statement is<\/p>\r\n<pre>    [~,e] = log2(x)<\/pre>\r\n<p>With two output arguments, <tt>log2<\/tt> returns the mantissa and exponent of an IEEE-754 floating point number. The mantissa is not needed here.<\/p>\r\n<p>The second key statement<\/p>\r\n<pre>    e = ceil(e\/4)<\/pre>\r\n<p>makes <tt>e<\/tt> divisible by 4. This turns <tt>e<\/tt> into the appropriate hexadecimal exponent so that the third statement<\/p>\r\n<pre>    f = x.*16.^(-e)<\/pre>\r\n<p>can produce the hexadecimal mantissa.<\/p>\r\n<h4>\r\n<tt>ieee2ibm<\/tt><a name=\"126c1d80-75f5-4879-841f-de925f083fc1\"><\/a>\r\n<\/h4>\r\n<pre>function z = ieee2ibm(x)\r\n   Convert IEEE-754 to IBM System 360 hexadecimal.\r\n   z = ieee2ibm(x)\r\n      Input x, real column vector.\r\n      Output z, length(x)-by-16 char.\r\n   Example: ieee2ibm(-118.625) = 'C276A00000000000'.<\/pre>\r\n<pre>      s = sign(x);                      % -1, 0, or 1\r\n      x = abs(x);\r\n      x(x &lt; 16^(-65)) = 0;              % Underflow\r\n      x(x &gt;= 16^63) = (1-eps\/2)*16^63;  % Overflow<\/pre>\r\n<pre>      [~,e] = log2(x);                  % base 2 exponent\r\n      e = ceil(e\/4)                     % base 16 exponent\r\n      f = x.*16.^(-e);                  % base 16 mantissa<\/pre>\r\n<pre>      E = uint64((e+64)*2^56);          % Assemb1e output\r\n      F = uint64(f*2^56);\r\n      S = uint64((1-s)*2^62);           % 1 or 0\r\n      z = dec2hex(S + E + F);           % z = 'ZZFFFFFFFFFFFFFF'\r\nend<\/pre>\r\n<h4>\r\n<tt>ibm2ieee<\/tt><a name=\"88d3bc9c-b626-4578-872e-b95f02057e43\"><\/a>\r\n<\/h4>\r\n<pre>function x = ibm2ieee(z)\r\n   Convert IBM System 360 hexadecimal to IEEE-754.\r\n   x = ibm2ieee(z)\r\n      Input z, n-by-16 char.\r\n      Output x, n-by-1 double.\r\n   Example: ibm2ieee('C276A00000000000') = -118.625.<\/pre>\r\n<pre>      E = hex2dec(z(:,1:2));           % Disassemble input\r\n      F1 = hex2dec(z(:,3:8));          % &lt; 16^6\r\n      F2 = hex2dec(z(:,9:end));        % &lt; 16^8\r\n      s = sign(128-E);                 % -1 or 1<\/pre>\r\n<pre>      e = E-(s&gt;0)*64-(s&lt;0)*192;        % base 16 exponent\r\n      f = F1\/16^6 + F2\/16^14;          % base 16 mantissa\r\n      x = s.*f.*16.^e;\r\nend<\/pre>\r\n<h4>Examples<a name=\"64f8c2ec-011c-40a2-a2f3-a2926ee929ac\"><\/a>\r\n<\/h4>\r\n<p>Underflow. Anything <tt>&lt; 16^(-65)<\/tt> is too small and is flushed to zero. There are no denormals.<\/p>\r\n<p>Overflow. Anything <tt>&gt;= 16^63<\/tt> is too large. There is no <tt>inf<\/tt> or <tt>NaN<\/tt>.<\/p>\r\n<pre>* 1.0           4110000000000000\r\n* 0.1           401999999999999A\r\n* -pi           C13243F6A8885A30\r\n* 5.3976e-79    0010000000000000\r\n* 7.2370e+75    7FFFFFFFFFFFFFF8<\/pre>\r\n<h4>Comparison<a name=\"41ed0fce-64bf-4471-b2c3-e22645d184f5\"><\/a>\r\n<\/h4>\r\n<p>S\/360 hexadecimal has 7 exponent bits, while IEEE-754 has 11. Consequently, hexadecimal has a much smaller range, 5.4e-79 to 7.2e+75 versus 2.2e-308 to 1.8e+308.<\/p>\r\n<p>The base-16 normalization implies that hexadecimal effectively has between 53 and 56 mantissa bits. Counting the hidden bit, IEEE-754 also has 53. So, the accuracy of the two is pretty much the same.<\/p>\r\n<h4>Software<a name=\"9e4ce83f-58b7-498d-b480-9f17c5c1f6e0\"><\/a>\r\n<\/h4>\r\n<p>My functions <tt>ieee2ibm<\/tt> and <tt>ieee2ibm<\/tt> described above, modified to handle both single and double, plus <tt>hex_test<\/tt>, which does what its name implies, are available at <a href=\"https:\/\/blogs.mathworks.com\/cleve\/files\/Hex_ieee.m\"><tt>Hex_ieee<\/tt><\/a>.<\/p>\r\n<p>Homework: What happens?<\/p>\r\n<pre>ok = 0;\r\nfor k = 1:10\r\n     x = single(k\/10);\r\n     ok(k) = hex_test(x);\r\nend\r\nok<\/pre>\r\n<script language=\"JavaScript\"> <!-- \r\n    function grabCode_54dd3908d741477c9a1ad45b553487d5() {\r\n        \/\/ Remember the title so we can use it in the new page\r\n        title = document.title;\r\n\r\n        \/\/ Break up these strings so that their presence\r\n        \/\/ in the Javascript doesn't mess up the search for\r\n        \/\/ the MATLAB code.\r\n        t1='54dd3908d741477c9a1ad45b553487d5 ' + '##### ' + 'SOURCE BEGIN' + ' #####';\r\n        t2='##### ' + 'SOURCE END' + ' #####' + ' 54dd3908d741477c9a1ad45b553487d5';\r\n    \r\n        b=document.getElementsByTagName('body')[0];\r\n        i1=b.innerHTML.indexOf(t1)+t1.length;\r\n        i2=b.innerHTML.indexOf(t2);\r\n \r\n        code_string = b.innerHTML.substring(i1, i2);\r\n        code_string = code_string.replace(\/REPLACE_WITH_DASH_DASH\/g,'--');\r\n\r\n        \/\/ Use \/x3C\/g instead of the less-than character to avoid errors \r\n        \/\/ in the XML parser.\r\n        \/\/ Use '\\x26#60;' instead of '<' so that the XML parser\r\n        \/\/ doesn't go ahead and substitute the less-than character. \r\n        code_string = code_string.replace(\/\\x3C\/g, '\\x26#60;');\r\n\r\n        copyright = 'Copyright 2024 The MathWorks, Inc.';\r\n\r\n        w = window.open();\r\n        d = w.document;\r\n        d.write('<pre>\\n');\r\n        d.write(code_string);\r\n\r\n        \/\/ Add copyright line at the bottom if specified.\r\n        if (copyright.length > 0) {\r\n            d.writeln('');\r\n            d.writeln('%%');\r\n            if (copyright.length > 0) {\r\n                d.writeln('% _' + copyright + '_');\r\n            }\r\n        }\r\n\r\n        d.write('<\/pre>\\n');\r\n\r\n        d.title = title + ' (MATLAB code)';\r\n        d.close();\r\n    }   \r\n     --> <\/script>\r\n<p style=\"text-align: right; font-size: xx-small; font-weight:lighter;   font-style: italic; color: gray\">\r\n<br>\r\n<a href=\"javascript:grabCode_54dd3908d741477c9a1ad45b553487d5()\"><span style=\"font-size: x-small;        font-style: italic;\">Get \r\n      the MATLAB code <noscript>(requires JavaScript)<\/noscript>\r\n<\/span><\/a>\r\n<br>\r\n<br>\r\n      Published with MATLAB&reg; R2024a<br>\r\n<\/p>\r\n<\/div>\r\n<!--\r\n54dd3908d741477c9a1ad45b553487d5 ##### SOURCE BEGIN #####\r\n%% IBM Hexadecimal Floating Point\r\n% Our technical support group recently received a request\r\n% for a tool that would convert IBM System\/360 hexadecimal\r\n% floating point numbers to the IEEE-754 format.\r\n% I am probably the only one left at MathWorks that actually used\r\n% IBM mainframe computers.\r\n% I thought we had seen the last of hexadecimal arithmetic years ago.\r\n% But, it turns out that the hexadecimal floating point format\r\n% is alive and well.\r\n\r\n%% IBM System\/360\r\n% The System\/360 is a family of mainframe computers that IBM\r\n% introduced in 1965 and that dominated the computer industry\r\n% until PCs came along twenty years later.  They range in size\r\n% from desk-sized to systems that fill a large room.\r\n%\r\n% Here is a photo of a mid-sized model.\r\n%\r\n% <<ibm-360-60.png>>\r\n%\r\n% _System\/360, Model 60._\r\n% _Photo from Ken Shirrif's blog, IBM 360\/System Summary_.\r\n%\r\n% The System\/360 architecture is byte-oriented, so it can\r\n% handle business\r\n% data processing as well as scientific and engineering computation.\r\n% This leads to base-16, rather than base-2 or base-10,\r\n% floating point arithmetic.\r\n%\r\n%  * Binary      f*2^e    1\/2<=f<1\r\n%  * Decimal     f*10^e   1\/10<=f<1\r\n%  * Hexadecimal f*16^e   1\/16<=f<1\r\n\r\n%% Formats\r\n% Floating point formats played an important role in\r\n% technical computing in the early days.\r\n% This table from\r\n% <https:\/\/www.amazon.com\/exec\/obidos\/ASIN\/0131653326\/acmorg-20\r\n% FMM> lists formats that\r\n% were in use in the 1970s, before IEEE-754 was introduced in 1985.\r\n%\r\n% <<fmm2.png>>\r\n%\r\n\r\n%% Data\r\n% The System\/360 hexadecimal format is used in many industries for the\r\n% preservation of data files.\r\n%\r\n% <https:\/\/www.crewes.org\/ResearchLinks\/FreeSoftware CREWES>.\r\n% Teaching exploration seismology.\r\n% Comprehensive MATLAB toolbox for use with the textbook\r\n% \"Numerical Methods of Exploration Seismology with algorithms in Matlab\" \r\n% by Gary F. Margrave, a geoscience professor at the University of Calgary.\r\n%\r\n% <https:\/\/www.loc.gov\/preservation\/digital\/formats\/fdd\/fdd000464.shtml\r\n% Library of Congress>. Government.\r\n%\r\n% <https:\/\/nssdc.gsfc.nasa.gov\/nssdc\/formats\/IBM_32-Bit.html NASA>.\r\n% Astronautics.\r\n%\r\n% <https:\/\/support.sas.com\/content\/dam\/SAS\/support\/en\/technical-papers\/record-layout-of-a-sas-version-5-or-6-data-set-in-sas-transport-xport-format.pdf\r\n% SAS>.  \r\n% Statistics and business analytics.  SAS wrapers for C.\r\n%\r\n% <https:\/\/github.com\/enthought\/ibm2ieee Enthought>.  Python wrappers for C. \r\n%\r\n\r\n%% |Hex_ieee|\r\n% <https:\/\/blogs.mathworks.com\/cleve\/files\/Hex_ieee.m |Hex_ieee|>.\r\n% I have two twenty-line MATLAB functions, |ieee2ibm| and |ibm2ieee|,\r\n% that convert IEEE-754 floating point to and from IBM hexadecimal format.\r\n%\r\n% Three statements in the middle of |ieee2ibm| are the key to\r\n% the entire operation. The first statement is\r\n%\r\n%      [~,e] = log2(x)\r\n% \r\n% With two output arguments, |log2| returns the mantissa\r\n% and exponent of an IEEE-754 floating point number.\r\n% The mantissa is not needed here.\r\n%\r\n% The second key statement\r\n%\r\n%      e = ceil(e\/4) \r\n%\r\n% makes |e| divisible by 4. This turns |e| into the appropriate \r\n% hexadecimal exponent so that the third statement\r\n%\r\n%      f = x.*16.^(-e)\r\n% \r\n% can produce the hexadecimal mantissa.\r\n%   \r\n\r\n%% |ieee2ibm|\r\n%  function z = ieee2ibm(x)\r\n%     Convert IEEE-754 to IBM System 360 hexadecimal.\r\n%     z = ieee2ibm(x)\r\n%        Input x, real column vector.\r\n%        Output z, length(x)-by-16 char.\r\n%     Example: ieee2ibm(-118.625) = 'C276A00000000000'.\r\n%\r\n%        s = sign(x);                      % -1, 0, or 1\r\n%        x = abs(x);\r\n%        x(x < 16^(-65)) = 0;              % Underflow\r\n%        x(x >= 16^63) = (1-eps\/2)*16^63;  % Overflow\r\n%\r\n%        [~,e] = log2(x);                  % base 2 exponent\r\n%        e = ceil(e\/4)                     % base 16 exponent\r\n%        f = x.*16.^(-e);                  % base 16 mantissa\r\n%\r\n%        E = uint64((e+64)*2^56);          % Assemb1e output\r\n%        F = uint64(f*2^56);\r\n%        S = uint64((1-s)*2^62);           % 1 or 0\r\n%        z = dec2hex(S + E + F);           % z = 'ZZFFFFFFFFFFFFFF'\r\n% end\r\n\r\n%% |ibm2ieee|\r\n%  function x = ibm2ieee(z)\r\n%     Convert IBM System 360 hexadecimal to IEEE-754.\r\n%     x = ibm2ieee(z)\r\n%        Input z, n-by-16 char.\r\n%        Output x, n-by-1 double.\r\n%     Example: ibm2ieee('C276A00000000000') = -118.625.\r\n%\r\n%        E = hex2dec(z(:,1:2));           % Disassemble input\r\n%        F1 = hex2dec(z(:,3:8));          % < 16^6\r\n%        F2 = hex2dec(z(:,9:end));        % < 16^8\r\n%        s = sign(128-E);                 % -1 or 1\r\n%\r\n%        e = E-(s>0)*64-(s<0)*192;        % base 16 exponent\r\n%        f = F1\/16^6 + F2\/16^14;          % base 16 mantissa\r\n%        x = s.*f.*16.^e;\r\n%  end\r\n\r\n%% Examples\r\n% Underflow.  Anything |< 16^(-65)| is too small and is flushed to zero.\r\n% There are no denormals.\r\n%\r\n% Overflow.  Anything |>= 16^63| is too large.\r\n% There is no |inf| or |NaN|.\r\n%\r\n%  * 1.0           4110000000000000\r\n%  * 0.1           401999999999999A\r\n%  * -pi           C13243F6A8885A30\r\n%  * 5.3976e-79    0010000000000000\r\n%  * 7.2370e+75    7FFFFFFFFFFFFFF8\r\n\r\n%% Comparison\r\n% S\/360 hexadecimal has 7 exponent bits, while IEEE-754 has 11.\r\n% Consequently, hexadecimal has a much smaller range, 5.4e-79 to 7.2e+75\r\n% versus 2.2e-308 to 1.8e+308.\r\n%\r\n% The base-16 normalization implies that hexadecimal effectively has\r\n% between 53 and 56 mantissa bits.  Counting the hidden bit,\r\n% IEEE-754 also has 53.  So, the accuracy of the two is pretty much the\r\n% same.\r\n\r\n%% Software\r\n% My functions |ieee2ibm| and |ieee2ibm| described above,\r\n% modified to handle both single and double,\r\n% plus |hex_test|, which does what its name implies, are available at\r\n% <https:\/\/blogs.mathworks.com\/cleve\/files\/Hex_ieee.m |Hex_ieee|>.\r\n%\r\n% Homework: What happens?\r\n%\r\n%  ok = 0;\r\n%  for k = 1:10\r\n%       x = single(k\/10);\r\n%       ok(k) = hex_test(x);\r\n%  end\r\n%  ok\r\n\r\n\r\n##### SOURCE END ##### 54dd3908d741477c9a1ad45b553487d5\r\n-->\r\n","protected":false},"excerpt":{"rendered":"<div class=\"overview-image\"><img src=\"https:\/\/blogs.mathworks.com\/cleve\/files\/ibm-360.png\" class=\"img-responsive attachment-post-thumbnail size-post-thumbnail wp-post-image\" alt=\"\" decoding=\"async\" loading=\"lazy\" \/><\/div><!--introduction-->\r\n<p>Our technical support group recently received a request for a tool that would convert IBM System\/360 hexadecimal floating point numbers to the IEEE-754 format. I am probably the only one left at MathWorks that actually used IBM mainframe computers. I thought we had seen the last of hexadecimal arithmetic years ago. But, it turns out that the hexadecimal floating point format is alive and well.... <a class=\"read-more\" href=\"https:\/\/blogs.mathworks.com\/cleve\/2024\/05\/25\/ibm-hexadecimal-floating-point\/\">read more >><\/a><\/p>","protected":false},"author":78,"featured_media":11318,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[4,7,37],"tags":[],"_links":{"self":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts\/11324"}],"collection":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/users\/78"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/comments?post=11324"}],"version-history":[{"count":1,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts\/11324\/revisions"}],"predecessor-version":[{"id":11327,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts\/11324\/revisions\/11327"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/media\/11318"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/media?parent=11324"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/categories?post=11324"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/tags?post=11324"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}