Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

unit module Smooth::Numbers:ver<0.0.3>:auth<zef:thundergnat>;

sub smooth-numbers (*@list where @list.all >= 1 ) is export {
    fail "Need to supply at least one factor to routine" unless @list.elems > 0;
    my \Smooth := gather {
        my %i = (flat @list) Z=> (Smooth.iterator for ^@list);
        my %n = (flat @list) Z=> 1 xx *;

        loop {
            take my $n := %n{*}.min;
            -> \k { %n{k} = %i{k}.pull-one * k if %n{k} == $n } for @list;
        }
    }
}



Given a list of prime factors, return an iterator which will produce numbers
that are "smooth" to those factors.


=begin code :lang<raku>

use Smooth::Numbers;

my $Hammings = smooth-numbers(2,3,5);

put $Hammings[^20]; # 1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36

=end code


Smooth numbers are defined as "numbers that are products of small prime
factors."


Hamming numbers, which are the numbers that are products of 2, 3, 5, is the
classic example.


The first ten Hamming numbers ( 2,3,5 smooth numbers ) are:


=begin code :lang<raku>

1  ( 2⁰ * 3⁰ * 5⁰ )
2  ( 2¹ * 3⁰ * 5⁰ )
3  ( 2⁰ * 3¹ * 5⁰ )
4  ( 2² * 3⁰ * 5⁰ )
5  ( 2⁰ * 3⁰ * 5¹ )
6  ( 2¹ * 3¹ * 5⁰ )
8  ( 2³ * 3⁰ * 5⁰ )
9  ( 2⁰ * 3² * 5⁰ )
10 ( 2¹ * 3⁰ * 5¹ )
12 ( 2² * 3¹ * 5⁰ )

=end code


Smooth numbers are easy to conceptualize but can be challenging to generate in
order. This module provides a simple routine to overcome that.


=begin code :lang<raku>

sub smooth-numbers(*@factors)

=end code


Takes a list or array of factors and returns an iterator that generates an
ordered sequence of numbers that are smooth to those factors.


The factors need not be in any order, and need not be prime. Smooth numbers
traditionally are thought of as products of only prime factors, but if you want,
for instance, the products of powers of 4 and 9, this module will oblige.


=begin code :lang<raku>

put smooth-numbers(4,9)[^15];

# 1 4 9 16 36 64 81 144 256 324 576 729 1024 1296 2304

=end code


For that matter, there is no constraint that the "factors" need even be
integers.


=begin code :lang<raku>

put smooth-numbers(1.5,2.5)[^10];

# 1 1.5 2.25 2.5 3.375 3.75 5.0625 5.625 6.25 7.59375

=end code


item

Note that if I<any> of the factors is equal to 1, the sequence will return an
infinite series of 1s. Should be obvious why if you think about it.


This package is free software and is provided "as is" without express or implied
warranty. You can redistribute it and/or modify it under the same terms as Perl
itself.


Licensed under The Artistic 2.0; see LICENSE.


Numbers

# Interface to activate slangs at compile time inside slang modules

sub EXPORT(Mu $grammar, Mu $actions) {

    # The EXPORT sub that actually does the slanging
    my sub EXPORT() {
        my $LANG := $*LANG;
        $LANG.define_slang(
          'MAIN',
          $grammar<> =:= Mu
            ?? $LANG.slang_grammar('MAIN')
            !! $LANG.slang_grammar('MAIN').^mixin($grammar),
          $actions<> =:= Mu
            ?? $LANG.slang_actions('MAIN')
            !! $LANG.slang_actions('MAIN').^mixin($actions)
        );
        BEGIN Map.new
    }

    # Export the EXPORT sub that does the slanging
    Map.new: ('&EXPORT' => &EXPORT)
}



Slangify - Provide an easy interface to activating slangs


=begin code :lang<raku>

# Code of a slang module with only a grammar change
role Grammar { ... }
use Slangify Grammar, Mu;

# Code of a slang module with both grammar and actions
role Grammar { ... }
role Actions { ... }
use Slangify Grammar, Actions;

# Code of a slang module with only an actions change
role Actions { ... }
use Slangify Mu, Actions;

=end code


The C<Slangify> module is a module intended for slang developers.


It abstracts the internals of slang creation and activation so that
module developers of slangs have a consistent interface they can work
with across current and future versions of the Raku Programming Language.


This module is B<only> needed to install a module that provides a
slang.  And as such, would only need to be specified in the
C<build-depends> section of the META information.


Note that the absence of a grammar role or an actions role, can be
indicated by specifying C<Mu>.  Sadly, some core ideosyncracies make
it currently impossible to indicate no change otherwise.


Source can be located at: https://github.com/lizmat/Slangify . Comments and
Pull Requests are welcome.


If you like this module, or what I’m doing more generally, committing to a
L<small sponsorship|https://github.com/sponsors/lizmat/>  would mean a great
deal to me!


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


Slangify

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

Slangify v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation