Loading…
Computing floating-point logarithms with fixed-point operations
Elementary functions from the mathematical library input and output floating-point numbers. However it is possible to implement them purely using integer/fixed-point arithmetic. This option was not attractive between 1985 and 2005, because mainstream processor hardware supported 64-bit floating-poin...
Saved in:
Main Authors: | , , , |
---|---|
Format: | Conference Proceeding |
Language: | English |
Subjects: | |
Online Access: | Request full text |
Tags: |
Add Tag
No Tags, Be the first to tag this record!
|
cited_by | |
---|---|
cites | |
container_end_page | 163 |
container_issue | |
container_start_page | 156 |
container_title | |
container_volume | |
creator | Le Maire, Julien Brunie, Nicolas De Dinechin, Florent Muller, Jean-Michel |
description | Elementary functions from the mathematical library input and output floating-point numbers. However it is possible to implement them purely using integer/fixed-point arithmetic. This option was not attractive between 1985 and 2005, because mainstream processor hardware supported 64-bit floating-point, but only 32-bit integers. This has changed in recent years, in particular with the generalization of native 64-bit integer support. The purpose of this article is therefore to reevaluate the relevance of computing floating-point functions in fixed-point. For this, several variants of the double-precision logarithm function are implemented and evaluated. Formulating the problem as a fixed-point one is easy after the range has been (classically) reduced. Then, 64-bit integers provide slightly more accuracy than 53-bit mantissa, which helps speed up the evaluation. Finally, multi-word arithmetic, critical for accurate implementations, is much faster in fixed-point, and natively supported by recent compilers. Thanks to all this, a purely integer implementation of the correctly rounded double-precision logarithm outperforms the previous state of the art, with the worst-case execution time reduced by a factor 5. This work also introduces variants of the logarithm that input a floating-point number and output the result in fixed-point. These are shown to be both more accurate and more efficient than the traditional floating-point functions for some applications. |
doi_str_mv | 10.1109/ARITH.2016.24 |
format | conference_proceeding |
fullrecord | <record><control><sourceid>ieee_CHZPO</sourceid><recordid>TN_cdi_ieee_primary_7563285</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>7563285</ieee_id><sourcerecordid>7563285</sourcerecordid><originalsourceid>FETCH-LOGICAL-i214t-3d695b11d6a7e757bb56798ca168c7d93268680f9dece3c80f4b4446e9165ef13</originalsourceid><addsrcrecordid>eNotjFFLwzAUhSMoOOceffKlf6A1t0lucp9kFN0GA0Hm80jbdEbapjQV9d9bcU_fdziHw9gd8AyA08P6dXfYZjkHzHJ5wVakDShOcwbUl2wBHEWKxtA1u4nxg3MgQr1gj0Xohs_J96ekaYP9k3QIvp-SNpzs6Kf3LiZfM5LGf7v63IXBjfM29PGWXTW2jW515pK9PT8dim26f9nsivU-9TnIKRU1kioBarTaaaXLUqEmU1lAU-maRI4GDW-odpUT1WyylFKiI0DlGhBLdv__651zx2H0nR1_jlqhyI0Sv17iSTI</addsrcrecordid><sourcetype>Publisher</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Computing floating-point logarithms with fixed-point operations</title><source>IEEE Xplore All Conference Series</source><creator>Le Maire, Julien ; Brunie, Nicolas ; De Dinechin, Florent ; Muller, Jean-Michel</creator><creatorcontrib>Le Maire, Julien ; Brunie, Nicolas ; De Dinechin, Florent ; Muller, Jean-Michel</creatorcontrib><description>Elementary functions from the mathematical library input and output floating-point numbers. However it is possible to implement them purely using integer/fixed-point arithmetic. This option was not attractive between 1985 and 2005, because mainstream processor hardware supported 64-bit floating-point, but only 32-bit integers. This has changed in recent years, in particular with the generalization of native 64-bit integer support. The purpose of this article is therefore to reevaluate the relevance of computing floating-point functions in fixed-point. For this, several variants of the double-precision logarithm function are implemented and evaluated. Formulating the problem as a fixed-point one is easy after the range has been (classically) reduced. Then, 64-bit integers provide slightly more accuracy than 53-bit mantissa, which helps speed up the evaluation. Finally, multi-word arithmetic, critical for accurate implementations, is much faster in fixed-point, and natively supported by recent compilers. Thanks to all this, a purely integer implementation of the correctly rounded double-precision logarithm outperforms the previous state of the art, with the worst-case execution time reduced by a factor 5. This work also introduces variants of the logarithm that input a floating-point number and output the result in fixed-point. These are shown to be both more accurate and more efficient than the traditional floating-point functions for some applications.</description><identifier>ISSN: 1063-6889</identifier><identifier>EISBN: 9781509016167</identifier><identifier>EISBN: 1509016163</identifier><identifier>DOI: 10.1109/ARITH.2016.24</identifier><identifier>CODEN: IEEPAD</identifier><language>eng</language><publisher>IEEE</publisher><subject>Cognition ; correct rounding ; elementary function ; fixed-point ; floating-point ; Hardware ; Kernel ; logarithm ; Program processors ; Workstations ; Writing</subject><ispartof>2016 IEEE 23nd Symposium on Computer Arithmetic (ARITH), 2016, p.156-163</ispartof><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/7563285$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,776,780,785,786,27904,54534,54911</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/7563285$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Le Maire, Julien</creatorcontrib><creatorcontrib>Brunie, Nicolas</creatorcontrib><creatorcontrib>De Dinechin, Florent</creatorcontrib><creatorcontrib>Muller, Jean-Michel</creatorcontrib><title>Computing floating-point logarithms with fixed-point operations</title><title>2016 IEEE 23nd Symposium on Computer Arithmetic (ARITH)</title><addtitle>ARITH</addtitle><description>Elementary functions from the mathematical library input and output floating-point numbers. However it is possible to implement them purely using integer/fixed-point arithmetic. This option was not attractive between 1985 and 2005, because mainstream processor hardware supported 64-bit floating-point, but only 32-bit integers. This has changed in recent years, in particular with the generalization of native 64-bit integer support. The purpose of this article is therefore to reevaluate the relevance of computing floating-point functions in fixed-point. For this, several variants of the double-precision logarithm function are implemented and evaluated. Formulating the problem as a fixed-point one is easy after the range has been (classically) reduced. Then, 64-bit integers provide slightly more accuracy than 53-bit mantissa, which helps speed up the evaluation. Finally, multi-word arithmetic, critical for accurate implementations, is much faster in fixed-point, and natively supported by recent compilers. Thanks to all this, a purely integer implementation of the correctly rounded double-precision logarithm outperforms the previous state of the art, with the worst-case execution time reduced by a factor 5. This work also introduces variants of the logarithm that input a floating-point number and output the result in fixed-point. These are shown to be both more accurate and more efficient than the traditional floating-point functions for some applications.</description><subject>Cognition</subject><subject>correct rounding</subject><subject>elementary function</subject><subject>fixed-point</subject><subject>floating-point</subject><subject>Hardware</subject><subject>Kernel</subject><subject>logarithm</subject><subject>Program processors</subject><subject>Workstations</subject><subject>Writing</subject><issn>1063-6889</issn><isbn>9781509016167</isbn><isbn>1509016163</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2016</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><recordid>eNotjFFLwzAUhSMoOOceffKlf6A1t0lucp9kFN0GA0Hm80jbdEbapjQV9d9bcU_fdziHw9gd8AyA08P6dXfYZjkHzHJ5wVakDShOcwbUl2wBHEWKxtA1u4nxg3MgQr1gj0Xohs_J96ekaYP9k3QIvp-SNpzs6Kf3LiZfM5LGf7v63IXBjfM29PGWXTW2jW515pK9PT8dim26f9nsivU-9TnIKRU1kioBarTaaaXLUqEmU1lAU-maRI4GDW-odpUT1WyylFKiI0DlGhBLdv__651zx2H0nR1_jlqhyI0Sv17iSTI</recordid><startdate>201607</startdate><enddate>201607</enddate><creator>Le Maire, Julien</creator><creator>Brunie, Nicolas</creator><creator>De Dinechin, Florent</creator><creator>Muller, Jean-Michel</creator><general>IEEE</general><scope>6IE</scope><scope>6IH</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIO</scope></search><sort><creationdate>201607</creationdate><title>Computing floating-point logarithms with fixed-point operations</title><author>Le Maire, Julien ; Brunie, Nicolas ; De Dinechin, Florent ; Muller, Jean-Michel</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i214t-3d695b11d6a7e757bb56798ca168c7d93268680f9dece3c80f4b4446e9165ef13</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2016</creationdate><topic>Cognition</topic><topic>correct rounding</topic><topic>elementary function</topic><topic>fixed-point</topic><topic>floating-point</topic><topic>Hardware</topic><topic>Kernel</topic><topic>logarithm</topic><topic>Program processors</topic><topic>Workstations</topic><topic>Writing</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Le Maire, Julien</creatorcontrib><creatorcontrib>Brunie, Nicolas</creatorcontrib><creatorcontrib>De Dinechin, Florent</creatorcontrib><creatorcontrib>Muller, Jean-Michel</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan (POP) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE/IET Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP) 1998-present</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Le Maire, Julien</au><au>Brunie, Nicolas</au><au>De Dinechin, Florent</au><au>Muller, Jean-Michel</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Computing floating-point logarithms with fixed-point operations</atitle><btitle>2016 IEEE 23nd Symposium on Computer Arithmetic (ARITH)</btitle><stitle>ARITH</stitle><date>2016-07</date><risdate>2016</risdate><spage>156</spage><epage>163</epage><pages>156-163</pages><issn>1063-6889</issn><eisbn>9781509016167</eisbn><eisbn>1509016163</eisbn><coden>IEEPAD</coden><abstract>Elementary functions from the mathematical library input and output floating-point numbers. However it is possible to implement them purely using integer/fixed-point arithmetic. This option was not attractive between 1985 and 2005, because mainstream processor hardware supported 64-bit floating-point, but only 32-bit integers. This has changed in recent years, in particular with the generalization of native 64-bit integer support. The purpose of this article is therefore to reevaluate the relevance of computing floating-point functions in fixed-point. For this, several variants of the double-precision logarithm function are implemented and evaluated. Formulating the problem as a fixed-point one is easy after the range has been (classically) reduced. Then, 64-bit integers provide slightly more accuracy than 53-bit mantissa, which helps speed up the evaluation. Finally, multi-word arithmetic, critical for accurate implementations, is much faster in fixed-point, and natively supported by recent compilers. Thanks to all this, a purely integer implementation of the correctly rounded double-precision logarithm outperforms the previous state of the art, with the worst-case execution time reduced by a factor 5. This work also introduces variants of the logarithm that input a floating-point number and output the result in fixed-point. These are shown to be both more accurate and more efficient than the traditional floating-point functions for some applications.</abstract><pub>IEEE</pub><doi>10.1109/ARITH.2016.24</doi><tpages>8</tpages><oa>free_for_read</oa></addata></record> |
fulltext | fulltext_linktorsrc |
identifier | ISSN: 1063-6889 |
ispartof | 2016 IEEE 23nd Symposium on Computer Arithmetic (ARITH), 2016, p.156-163 |
issn | 1063-6889 |
language | eng |
recordid | cdi_ieee_primary_7563285 |
source | IEEE Xplore All Conference Series |
subjects | Cognition correct rounding elementary function fixed-point floating-point Hardware Kernel logarithm Program processors Workstations Writing |
title | Computing floating-point logarithms with fixed-point operations |
url | http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-21T12%3A12%3A32IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-ieee_CHZPO&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Computing%20floating-point%20logarithms%20with%20fixed-point%20operations&rft.btitle=2016%20IEEE%2023nd%20Symposium%20on%20Computer%20Arithmetic%20(ARITH)&rft.au=Le%20Maire,%20Julien&rft.date=2016-07&rft.spage=156&rft.epage=163&rft.pages=156-163&rft.issn=1063-6889&rft.coden=IEEPAD&rft_id=info:doi/10.1109/ARITH.2016.24&rft.eisbn=9781509016167&rft.eisbn_list=1509016163&rft_dat=%3Cieee_CHZPO%3E7563285%3C/ieee_CHZPO%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-i214t-3d695b11d6a7e757bb56798ca168c7d93268680f9dece3c80f4b4446e9165ef13%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=7563285&rfr_iscdi=true |