Langage de programmation - C++ - Référence de procédures et de fonctions

FREXP	Mantisse et exposant
Langage C++	cmath (math.h)

Syntaxe

float frexp(float x, int *ptrexposant);

double frexp(double x,int *ptrexposant)

long double frexp(long double x, int *ptrexposant);

Paramètres

Nom	Description
x	Ce paramètre permet d'indiquer l'expression contenant le nombre à traiter
ptrexposant	Ce paramètre permet d'indiquer l'exposant à retourner

Description

Cette fonction permet d'effectuer la séparation de la mantisse et de l'exposant.

Remarques

La fonction frexp() décompose le nombre x en une mantisse comprise entre 0,5 et moins de 1, et un exposant entier tel que x = mantissa * 2^ptrexposant. La mantisse est retournée par la fonction, et l'exposant est entreposé dans la variable pointée par ptrexposant.
Gère les nombres négatifs : frexp fonctionne aussi avec les nombres négatifs. Si x est négatif, la mantisse retournée est également négative, mais l'exposant reste positif ou nul. Exemple :



double mantisse = frexp(-12.0, &exp);

donnera une mantisse négative et un exposant positif.

Comportement pour x = 0 : Si x est 0.0, la fonction retourne 0.0 comme mantisse et entrepose 0 dans exp. Cela permet d'éviter des erreurs et de traiter correctement les cas où x est nul sans risque de division par zéro.
Relation avec ldexp : frexp est souvent utilisée avec ldexp, effectuant l'opération inverse :



double x = 10.5;

int exp;

double mantisse = frexp(x, &exp);

double reconstructed = ldexp(mantisse, exp); // Devrait donner 10.5

Cela est utile en calcul scientifique et en traitement numérique pour manipuler les exposants de manière efficace.

Version pour différents types flottants : Il existe plusieurs surcharges de frexp pour différents types :



float frexp(float x, int *exp);              // Pour float

long double frexp(long double x, int *exp);  // Pour long double

Cela garantit la compatibilité avec différents niveaux de précision en fonction des besoins.

Utilité en arithmétique flottante : frexp est très utile en arithmétique flottante pour : normaliser des nombres, extraire des exposants, analyser la précision d'un calcul et éviter des dépassements de capacité (overflow) en réduisant temporairement la magnitude des nombres avant certaines opérations.

Exemple

Voici un exemple de la génération des valeurs de cette fonction :

Essayer maintenant !


				
#include <iostream>

#include <cmath>

 

int main()

{

    double Mantissa;

    int I,Exponent;

    for(I = 1; I <= 9; I++) {

        Mantissa = frexp(I,&Exponent);

        std::cout << "frexp(" << I << ") = (" << Mantissa << "," << Exponent << ")" << std::endl;

    }

    return 0;

}

on obtiendra le résultat suivant :

frexp(1) = (0.5000,1) frexp(2) = (0.5000,2) frexp(3) = (0.7500,2) frexp(4) = (0.5000,3) frexp(5) = (0.6250,3) frexp(6) = (0.7500,3) frexp(7) = (0.8750,3) frexp(8) = (0.5000,4) frexp(9) = (0.5625,4)

Voir également

Langage de programmation - C++ - Référence de procédures et fonctions - exp
Langage de programmation - C++ - Référence de procédures et fonctions - ldexp
Langage de programmation - C - Référence de procédures et fonctions - frexp

Références

Langage C, Edition Micro-Application, Gehard Willms, 2001, ISBN: 2-7429-2008-0, page 732.
Borland C++ for Windows 4.0, Library Reference, Edition Borland, 1993, Part # BCP1240WW21772, page 113.

PARTAGER CETTE PAGE SUR

Dernière mise à jour : Lundi, le 3 août 2015

	ABAP/4
	Ada
	Assembleur
	Assembly & bytecode
	ASP (Active Server Pages)
	Basic
	C
	C++
	C# (C Sharp)
	Cobol
	ColdFusion
	Fortran
	HTML
	Java
	JavaScript
	LISP
	Logo
	LotusScript
	Oberon
	Pascal
	Perl
	PHP
	PL/1
	Prolog
	Python
	Rebol
	REXX
	Ruby
	SAS
	NoSQL
	SQL
	Swift
	X++ (Axapta)

	Assembleur 370
	Assembleur 1802
	Assembleur 4004
	Assembleur 6502
	Assembleur 6800
	Assembleur 68000
	Assembleur 8080 et 8085
	Assembleur 8089
	Assembleur 80x86
	Assembleur AGC4
	Assembleur ARM
	Assembleur DPS 8000
	Assembleur i860
	Assembleur Itanium
	Assembleur MIPS
	Assembleur PDP-11
	Assembleur PowerPC
	Assembleur RISC-V
	Assembleur SPARC
	Assembleur SuperH
	Assembleur UNIVAC I
	Assembleur VAX
	Assembleur Z80
	Assembleur Z8000
	Assembleur z/Architecture

	CIL
	Jasmin
	LLVM
	MSIL
	Parrot
	P-Code (PCode)
	SWEET16

	ASP 1.0
	ASP 2.0
	ASP 3.0
	ASP.NET

	ABasiC (Amiga)
	Adam SmartBASIC
	Altair BASIC
	AmigaBASIC (Amiga)
	AMOS Basic (Amiga)
	Atari Basic (Atari 400, 600 XL, 800, 800XL)
	Basic Apple II (Integer BASIC/APPLESOFT)
	Basic Commodore 64 (CBM-BASIC)
	Basic Commodore 128 (BASIC 7.0)
	Basic Commodore VIC-20 (CBM-BASIC 2.0)
	Basic Coco 1 (Color Basic)
	Basic Coco 2 (Extended Color Basic)
	Basic Coco 3 (Extended Color Basic 2.0)
	BASICA (PC DOS)
	Basic Pro
	BBC BASIC
	Blitz BASIC (Amiga)
	DarkBASIC
	Dartmouth BASIC
	GFA-Basic (Atari ST/Amiga)
	GWBASIC (MS-DOS)
	Liberty BASIC
	Locomotive BASIC (Amstrad CPC)
	MSX-Basic
	Omikron Basic (Atari ST)
	Oric Extended Basic
	Power Basic
	Quick Basic/QBasic (MS-DOS)
	Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
	ST BASIC (Atari ST)
	Turbo Basic
	Vintage BASIC
	VBScript
	Visual Basic (VB)
	Visual Basic .NET (VB .NET)
	Visual Basic pour DOS
	Yabasic

Section courante

A propos

Section administrative du site

FREXP