FEED Validator

for Atom and RSS and KML

Sorry

This feed does not validate.

line 1, column 0: Undefined root element: br [help]
```
 
```
line 2, column 0: XML parsing error: <unknown>:2:0: junk after document element [help]
```
Warning:  Undefined variable $out in /home/bakers/html/perturb.cla ...
```

In addition, interoperability with the widest range of feed readers could be improved by implementing the following recommendation.

"text/xml" media type is not specific enough [help]

Source: http://www.perturb.org/atom.php

 
Warning: Undefined variable $out in /home/bakers/html/perturb.class.php on line 1314 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
 
Warning: Undefined variable $summary in /home/bakers/html/perturb.class.php on line 1353 
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet type="text/css" href="/css/atom-browser.css" ?>
<feed version="0.3" xmlns="http://purl.org/atom/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xml:lang="en"> <title>Perturb.org - Scott's Geek Blog</title>
<modified>2025-08-28T14:17:19-07:00</modified> <link rel="alternate" type="text/html" href="http://www.perturb.org" /> <tagline>Geek blog</tagline>
<id>tag:www.perturb.org,2025://08</id>
<generator>Perturb ATOM v0.1</generator>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1433/" />
<title mode="escaped">Perl: Search and replace a string across your entire code base</title>
<modified>2025-08-20T08:15:57-07:00</modified>
<issued>2025-08-20T08:15:57-07:00</issued>
<created>2025-08-20T08:15:57-07:00</created>
<id>http://www.perturb.org/display/entry/1433/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
I wanted to rename a function anywhere it was found in my code base. This requires going through every file and directory recursively, and checking each file. Using the Linux `find` command we can find *all* the files and then hand the search and replace off to Perl. Easy peasy.
 
```bash
find codebase/ -type f -exec perl -pi -E 's/foo/bar/g' {} + 
```
 
or using `fd` instead:
 
```bash
fd . codebase/ --type f --exec-batch -pi -E 's/foo/bar/g' {} 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1432/" />
<title mode="escaped">Linux: Testing for x86_64-v3</title>
<modified>2025-07-29T16:29:18-07:00</modified>
<issued>2025-07-29T16:29:18-07:00</issued>
<created>2025-07-29T16:29:18-07:00</created>
<id>http://www.perturb.org/display/entry/1432/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
Modern Linux distributions are starting to require [x86_64-v3](https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels) capable CPUs to run. If you do not have a CPU modern enough you may not be able to install certain versions of Linux. To test if your hardware is capable you can run the following command: 
 
```
/usr/lib64/ld-linux-x86-64.so.2 --help 
```
 
Basically any CPU made after 2015 will be fine.
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1431/" />
<title mode="escaped">PHP: Only start a session when it's needed</title>
<modified>2025-06-21T11:29:02-07:00</modified>
<issued>2025-06-21T11:29:02-07:00</issued>
<created>2025-06-21T11:29:02-07:00</created>
<id>http://www.perturb.org/display/entry/1431/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
I use sessions on my sites for user authentication. Calling `session_start()` initiates a session and allows me to check if the user is logged in or not. However, calling `session_start()` creates a new session for **every** hit on your site: bots, unauthenticated users, etc. This can lead to an _excess_ of session files on your filesystem.
 
A better way is to explicitly call `start_session()` when your user logs in. On your other pages you can check if the user has the appropriate session cookie and start a session **only** when it's needed.
 
```PHP
function start_session_if_exists() { 
if (isset($_COOKIE[session_name()]) && session_status() !== PHP_SESSION_ACTIVE) { 
session_start(); 
} 
} 
```
 
This will avoid creating a session for every hit on your site.
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1430/" />
<title mode="escaped">CSS: Selecting text made easy</title>
<modified>2025-06-17T09:58:19-07:00</modified>
<issued>2025-06-17T09:58:19-07:00</issued>
<created>2025-06-17T09:58:19-07:00</created>
<id>http://www.perturb.org/display/entry/1430/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
You can apply the [user-select](https://developer.mozilla.org/en-US/docs/Web/CSS/user-select) CSS property to an element to control how it handles selecting text for copy and paste. This allows you to limit selecting text, or make it automatic. If you use the `all` property, anytime a user clicks on that element the text is automatically selected. This can be useful for keys or codes where the user is **expected** to copy and paste the text.
 
```css
.click_select { user-select: all; } 
```
 
Example: 
 
<style> 
.click_select { 
user-select: all; 
} 
.test_button { 
border: 1px solid black; 
padding: 12px; 
border-radius: 4px; 
background: darkblue; 
} 
</style> 
 
Click me!
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1429/" />
<title mode="escaped">Linux: Find all the text files in a directory</title>
<modified>2025-06-06T18:30:02-07:00</modified>
<issued>2025-06-06T18:30:02-07:00</issued>
<created>2025-06-06T18:30:02-07:00</created>
<id>http://www.perturb.org/display/entry/1429/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
I need to find all the _text_ files in a given directory for potential clean up. There is not a super easy way to find only text files, but I came up with a hacky solution: 
 
```bash
# Using `fd` (new hotness)
fd . /tmp/ --exec file {} + | grep -P ":.*text" | cut -d: -f1 
 
# Using old school `find` (old and busted)
find /tmp/ -exec file {} + | grep -P ":.*text" | cut -d: -f1 
```
 
These rely on the `file` command to determine what the filetype is.
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1428/" />
<title mode="escaped">Javascript: Copy string to clipboard</title>
<modified>2025-06-03T15:25:29-07:00</modified>
<issued>2025-06-03T15:25:29-07:00</issued>
<created>2025-06-03T15:25:29-07:00</created>
<id>http://www.perturb.org/display/entry/1428/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
I needed a modern way to copy a string to the clipboard in JavaScript. [Claude.ai](https://claude.ai) helped me come up with this: 
 
```javascript
// With async/await 
async function copyToClipboard(text) { 
try { 
await navigator.clipboard.writeText(text); 
console.log('Copied to clipboard'); 
} catch (err) { 
console.error('Failed to copy: ', err); 
} 
} 
```
 
Then you simply call it with a string 
 
```javascript
copyToClipboard("Hello world"); 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1427/" />
<title mode="escaped">Rocky 10 package versions</title>
<modified>2025-06-02T15:10:07-07:00</modified>
<issued>2025-06-02T15:10:07-07:00</issued>
<created>2025-06-02T15:10:07-07:00</created>
<id>http://www.perturb.org/display/entry/1427/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
RedHat Enterprise Linux/Rocky 10 has these versions of packages: 
 
| Package | Version | 
| ------- | -------- | 
| Apache | 2.4.63 | 
| GCC | 14.2.1 | 
| Git | 2.47.1 | 
| Kernel | 6.12 | 
| MariaDB | 10.11.11 | 
| OpenSSH | 9.9p1 | 
| Perl | 5.40.2 | 
| PHP | 8.3.19 | 
| Vim | 9.1.83 |
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1426/" />
<title mode="escaped">Javascript: Returning data from an AJAX call</title>
<modified>2025-05-28T19:59:48-07:00</modified>
<issued>2025-05-28T19:59:48-07:00</issued>
<created>2025-05-28T19:59:48-07:00</created>
<id>http://www.perturb.org/display/entry/1426/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
Javascript is by it's nature asynchronous, which makes returning data from an AJAX call complicated. Modern Javascript uses the concept of a "[promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)" to allow you to run code after an asynchronous call competes. This is similar to using a callback function, but it reads cleaner. JQuery implements this type of call with the [`then()`](https://api.jquery.com/deferred.then/) function. A simple example is as follows:
 
```javascript
function getData() { 
return $.ajax({ 
url: '/api/data' 
}); 
} 
 
// Usage 
getData().then(function(data) { 
console.log(data); 
}); 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1425/" />
<title mode="escaped">PHP: Generate secure password hashes from the CLI</title>
<modified>2025-05-24T20:13:35-07:00</modified>
<issued>2025-05-24T20:13:35-07:00</issued>
<created>2025-05-24T20:13:35-07:00</created>
<id>http://www.perturb.org/display/entry/1425/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
The `password_hash()` function in PHP is excellent for storing passwords securely. In order to generate password to store in a database or config file I like to generate passwords from the CLI. This has the risk of storing the password in your bash history. This command prompts you for the password on the fly and protects your history.
 
```bash
php -r 'echo "Password: "; $pwd = trim(fgets(STDIN)); echo password_hash($pwd, PASSWORD_DEFAULT) . "\n";' 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1424/" />
<title mode="escaped">Vim: Insert a line of characters</title>
<modified>2025-04-01T00:00:00-07:00</modified>
<issued>2025-04-01T00:00:00-07:00</issued>
<created>2025-04-01T00:00:00-07:00</created>
<id>http://www.perturb.org/display/entry/1424/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
I need an 80 character divider of text in Vim. I can never remember the sequence so I'm writing it down: 
 
```
80i/<ESC> 
```
 
Will generate: 
 
```text
//////////////////////////////////////////////////////////////////////////////// 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1423/" />
<title mode="escaped">Comparing 32bit and 64bit performance on low end micro-controllers</title>
<modified>2025-03-05T13:47:09-08:00</modified>
<issued>2025-03-05T13:47:09-08:00</issued>
<created>2025-03-05T13:47:09-08:00</created>
<id>http://www.perturb.org/display/entry/1423/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
Testing 32bit vs 64bit PRNGs on a 32bit ESP32-C3 [I'm seeing](https://gist.github.com/scottchiefbaker/e4c87de8d6c1ad4a33b1ffe5a3ce707f): 
 
| PRNG | Iterations per second | Output Bits | Bytes per second | 
| ------------- | --------------------- | ----------- | ---------------- | 
| pcg32 | 487802 | 32 | **1951266.7 b/s**| 
| xoroshiro64** | **516023** | 32 | 2050966.7 b/s | 
| xoshiro256+ | 487808 | 64 | **3878726.7 b/s**| 
| xoshiro512++ | 441735 | 64 | 3514373.3 b/s | 
| splitmix64 | 462290 | 64 | 3677033.3 b/s | 
| pcg64 | **416297** | 64 | 3313060.0 b/s | 
 
Very little difference on PRNGs that use 64bit operations vs 32bit operations. Even on limited hardware like this it makes sense to use a 64bit PRNG because you get more bytes per cycle.
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1422/" />
<title mode="escaped">Vim: Convert your syntax highlighted text into HTML</title>
<modified>2025-02-26T00:00:00-08:00</modified>
<issued>2025-02-26T00:00:00-08:00</issued>
<created>2025-02-26T00:00:00-08:00</created>
<id>http://www.perturb.org/display/entry/1422/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
Vim is my code editor of choice as it has great features, excellent syntax highlighting, and a robust plug-in infrastructure. I'm very used to look and feel of Vim. If you want to share some of your code online, converting things to HTML can be problematic. Luckily Vim has a built in code to HTML converter: 
 
```
:TOhtml 
```
 
Simply run the `:TOhtml` command in an open text file and your buffer will be redrawn in HTML which you can then save. Here is a quick sample of my pcg32.pl script [converted to HTML](https://www.perturb.org/code/pcg32.pl.html).
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1421/" />
<title mode="escaped">What kind of number makes a good seed for a PRNG?</title>
<modified>2025-02-20T00:00:00-08:00</modified>
<issued>2025-02-20T00:00:00-08:00</issued>
<created>2025-02-20T00:00:00-08:00</created>
<id>http://www.perturb.org/display/entry/1421/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
[Pseudo-random number generators](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) use complex math to generate random numbers on your computer. These random numbers are used for all sorts of things: simulations, fractals, games, art, and even math experiments. Computers can **only** do math, which makes generating a random number difficult. 
 
PRNGs need a "seed" number to kick off the math that generates sequences of random numbers. Some PRNGs require a 32bit seed, and some require a 64bit seed. Some PRNGs require one seed, and some require four (or more). It is important to know what type of seed your PRNG needs. 
 
A 32bit number is between 0 and 4.2 billion and a 64bit number is between 0 and 18.4 quintillion. The larger a number is, the more bits are required to store it, and the better a seed it will make. The closer your seed is to the upper end of the number range the better. As a general rule a good seed will be a decimal number with 18 or 19 digits. 
 
`12` is a small number and **not** a good seed, `4611686018427387906` is a big number but still not a great seed. Seeds should **not** have large sections of zero/one bits. This is why small numbers do not make good seeds. Bits can be visualized by printing the number in binary:
 
```bash
# Horrible 
$ perl -E 'printf("%064b\n", 4611686018427387906)' 
0100000000000000000000000000000000000000000000000000000000000010 
 
# Bad 
$ perl -E 'printf("%064b\n", 17770)' 
0000000000000000000000000000000000000000000000000100010101101010 
 
# Poor 
$ perl -E 'printf("%064b\n", 2850756010)' 
0000000000000000000000000000000010101001111010110001010110101010 
 
# Good 
$ perl -E 'printf("%064b\n", 11337502976607798025)' 
1001110101010110111001101110001101111000101001000100001100001001 
```
 
Good seeds should have a _roughly_ even mix of zero and one bits. `9223372036854775808` is a large number and looks promising but it has 63 zeros, and only a single one bit. You can visualize the quality of your seed with [seed_quality.pl](https://www.perturb.org/code/seed_quality.pl). Quality above 75% should make for good seed numbers.
 
Seeds should **not** be predictable. Do not use dates, times, or phone numbers as they are potentially guessable. Combinations of numbers can be good sources. Process PID, UID, unixtime are good potential sources _if_ they are combined together in a non-predictable way. PID multiplied by UID multiplied by Unixtime is an example of combining values. Memory locations of variables, especially if [ASLR](https://en.wikipedia.org/wiki/Address_space_layout_randomization) is in use is a potentially good source as well.
 
Hashing numbers, strings, or combinations of numbers can be a good way to generate seeds. Hashing a value with [Komihash](https://github.com/scottchiefbaker/perl-Crypt-Komihash) or [xxHash](https://metacpan.org/pod/Digest::xxHash) will generate a suitable 64bit number. Hashing a value with [SHA256](https://metacpan.org/pod/Digest::SHA) will generate a 256bit value which can be [split](https://www.perturb.org/display/1415_Perl_Using_sha256_to_hash_strings_into_integers.html) into four 64bit values. Hashing functions also do a good job of ensuring the bits are mixed well and do not include large repeating sections.
 
The best source of seed numbers is directly from your OS. On Linux this is `/dev/urandom` and on Windows you can interface with the `RtlGenRandom` API. These are carefully curated sources of _true_ randomness, but they can be slow-ish. Using them as a source for a fast PRNG is best practice.
 
```perl
sub get_64bit_seed { 
open my $urandom, '<:raw', '/dev/urandom' or croak("Couldn't open /dev/urandom: $!"); 
sysread($urandom, my $buf, 8) or croak("Couldn't read from csprng: $!"); 
 
return unpack("Q*", $buf); 
} 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1420/" />
<title mode="escaped">Perl: Multiply-Shift Hash</title>
<modified>2025-01-27T00:00:00-08:00</modified>
<issued>2025-01-27T00:00:00-08:00</issued>
<created>2025-01-27T00:00:00-08:00</created>
<id>http://www.perturb.org/display/entry/1420/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
I've been using the multiply-shift hash lately and have had good results. It's simple, fast, and well tested. 
 
```c
// Multiply-Shift Hash 
static uint64_t hash_msh(uint64_t x) { 
uint64_t prime = 0x9e3779b97f4a7c15; // A large prime constant 
x ^= (x >> 30); 
x *= prime; 
x ^= (x >> 27); 
x *= prime; 
x ^= (x >> 31); 
return x; 
} 
```
 
Whenever I find interesting code like this I like to try and implement it in Perl: 
 
```perl
sub hash_msh { 
my $x = $_[0]; 
my $prime = 11400714819323198485; 
 
$x ^= ($x >> 30); 
$x = multiply_uv($x, $prime); 
$x ^= ($x >> 27); 
$x = multiply_uv($x, $prime); 
$x ^= ($x >> 31); 
 
return $x; 
} 
 
# Perl converts numbers larger than 2^64 - 1 to floating point so 
# we 'use integer' to force integer math which retains any overflow. 
sub multiply_uv { 
my ($one, $two) = @_; 
 
use integer; 
my $ret = $one * $two; 
no integer; 
 
# Convert signed IV to unsinged UV 
if ($ret < 0) { 
$ret += 18446744073709551615; 
$ret += 1; 
} 
 
return $ret; 
} 
```
]]>
</content>
</entry>
<entry xmlns="http://purl.org/atom/ns#">
<link rel="alternate" type="text/html" href="http://www.perturb.org/display/entry/1419/" />
<title mode="escaped">Perl: Calculate number of bits needed to store a number</title>
<modified>2025-01-27T00:00:00-08:00</modified>
<issued>2025-01-27T00:00:00-08:00</issued>
<created>2025-01-27T00:00:00-08:00</created>
<id>http://www.perturb.org/display/entry/1419/</id>
<summary type="text/plain"></summary>
<author>
<name>Scott Baker</name>
<url>http://www.perturb.org/</url>
<email>scott@perturb.org</email>
</author>
<content type="text/html" mode="escaped" xml:lang="en" xml:base="http://www.perturb.org">
<![CDATA[<link rel="stylesheet" type="text/css" media="screen" href="/css/rss-feed.css" title="Default" />
Quick Perl function to calculate the number of bits required to store a given number. 
 
```perl
sub bits_required { 
my ($n) = @_; 
 
# Handle special case for 0 
return 0 if $n == 0; 
 
# Use logarithm to calculate the number of bits 
my $bits = int(log($n) / log(2)) + 1; 
return $bits; 
} 
```
]]>
</content>
</entry>
</feed>

Home · About · News · Docs · Terms