$ perl -Mbigint -E 'say 4335043554366887798866555766->as_hex'
0xe01dd2df9232f704e25b376
[download]

Wait, there's more, we can also adapt Re: Opposite of strtol? like this.

This goes to the file Tohex.xs:

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <gmp.h>

MODULE = Math::Tohex  PACKAGE = Math::Tohex

SV *
tohex(num)
        char *num
    CODE:
        char *out;
        ST(0) = sv_newmortal();
        mpz_t big;
        mpz_init_set_str(big, num, 10);
        Newx(out, 4 + mpz_sizeinbase(big, 16), char);
        mpz_get_str(out, 16, big);
        sv_setpv(ST(0), out);
        mpz_clear(big);
        Safefree(out);
[download]

This goes to the file lib/Math/Tohex.pm:

package Math::Tohex;

require Exporter;
require DynaLoader;
our $VERSION = "1.00";
our @ISA = (Exporter::, DynaLoader::);
our @EXPORT = "tohex";

bootstrap Math::Tohex::;

1;
__END__
[download]

And this goes to Makefile.PL:

use ExtUtils::MakeMaker;

WriteMakefile(
    NAME => "Math::Tohex",
    VERSION_FROM => "lib/Math/Tohex.pm",
    LIBS => ["-lgmp"],
);
[download]

Now compile:

perl Makefile.PL && make
[download]

and run:

perl -wE 'use Math::BigInt; say Math::BigInt->new("4335043554366887798
+866555766")->as_hex;'
[download]

and hope for no stupid mistakes leading to memory corruption.

Let me implement the other algorithm too. This one is longer, but you could cut some of it if you reorganized it so that there's only one function doing the work of all three.

use 5.010; 
{
no warnings "uninitialized";
sub dadd {
        my($a, $b) = @_; my @b = @$b; my $c;
        for (my $k = 0; @b || $c; $k++) {
                $c = 10 <= ($$a[$k] += $c + shift @b); $$a[$k] %= 10;
        }
}
sub dsub {
        my($a, $b) = @_; my @b = @$b; my $c;
        for (my $k = 0; $k < @$a; $k++) {
                $c = ($$a[$k] -= $c + shift @b) < 0; $$a[$k] += 10 * $
+c;
        }
    $c;
}
sub dcmp {
        my($a, $b) = @_; my @a = @$a; my @b = @$b; my $r;
    while (@a || @b) {
        if (my $t = shift @a <=> shift @b) { $r = $t; }
    }
    $r;
}
}
my $n = [reverse split //, "4335043554366887798866555766"];
my $p = [1];
my $e = 0;
while (0 <= dcmp($n, $p)) { 
        dadd $p, $p for 0..3; $e++;
}
my $r;
for my $_e (0 .. $e - 1) {
        dadd $n, $n for 0..3;
        my $i = 0;
        while (0 <= dcmp ($n, $p)) {
                dsub $n, $p; $i++;
        }
        $r .= sprintf "%x", $i;
}
say $r;
__END__
[download]

Okay, here's it a bit shortened:

use 5.010; 
sub dalu {
        no warnings "uninitialized";
        my($a, $b, $n, $o) = @_; my @b = @$b; my $c = $n && 1;
        for (my $k = 0; @b || $k < @$a || $c && !$n; $k++) {
                my $y = shift @b; $n and $y = 9 - $y;
                $c = 10 <= (my $z = $$a[$k] + $c + $y); 
                $o or $$a[$k] = $z % 10;
        }
        $c;
}
my $n = [reverse split //, "4335043554366887798866555766"];
my $p = [1];
my $e = 0;
while (dalu $n, $p, 1, 1) { 
        dalu $p, $p for 0..3; $e++;
}
my $r;
for my $_e (0 .. $e - 1) {
        dalu $n, $n for 0..3;
        my $i = 0;
        while (dalu $n, $p, 1, 1) {
                dalu $n, $p, 1; $i++;
        }
        $r .= sprintf "%x", $i;
}
say $r;
__END__
[download]

Update: made code a bit nicer.

$hex = `echo "obase=16; 4335043554366887798866555766"|bc`; chomp $hex;
print $hex;
[download]