Featured

Common Base Conversions

by 12:37 PM
Source: https://www.tes.com/teaching-resource/0-9-digit-cards-6044974
When we represent numbers in mathematics, we utilize ten digits zero to nine to represent all numbers. In computer science, this is called the base 10 system because it has ten digits. There are three other common bases that are studied in C.S.: base 2, 8 and 16, with two, eight and sixteen digits, respectively. Before we examine each of these in more detail, your are probably asking...

Why do we need to learn manual base conversions?

Although humans read in base-10, computers read in base-2 as the internal mechanisms can only reliably provide two options (i.e. are switches) that make data storage only possible in binary. But as the number gets larger the characters of binary get much larger and unwieldy to work with when examining computer codes. In the past, base-8 was used to shorten these long strings of numbers into more manageable chunks, but today this base-16 has supplanted octal in this role because it is more efficient. Now, we will move onto how to convert between these systems. We will use "binary" as a base case from which you can access the other bases (i.e. you would not convert directly from decimal to octal, but from decimal to binary and then from binary to octal).

Binary and Decimal:

First we examine the question of how to convert between our native number system and binary.
Source: https://www.geeksforgeeks.org/program-binary-decimal-conversion/
It is pretty intuitive to convert from binary to decimal. This is a base two system, and each extra digit represents a larger power of two. Since we only have two options, you will add either that power of two or not depending on whether the digit is zero or one.
Source: https://brilliant.org/wiki/binary-coded-decimal-or-bcd/
This table tells you how the decimal digits themselves are converted to binary numbers and vice-versa.
Source: https://owlcation.com/stem/How-to-Convert-Decimal-to-Binary-and-Binary-to-Decimal
There is also a rather intuitive way to convert decimals to binary using long division as shown above. This also relies on the powers of two, but instead of multiplication as in the prior conversion it uses division.

Binary and Octal:
Source: https://www.wikihow.com/Convert-Binary-to-Octal-Number
The relationship between octal and binary is based on this 4-2-1 relationship based on the cluster of the binary number, starting from the right in groups of three. If the final group (the most left-most or at the front of the number), does not have three, then you add on zeroes until you reach three. Then you write 4-2-1 and multiply by the available digits to generate the octal digits.
Another example of binary to octal: https://circuitglobe.com/octal-to-binary-and-binary-to-octal-conversion-methods.html
Chart for the octal digits: https://www.youtube.com/watch?v=a4i1OnDtufc
Converting from octal to binary requires an intuitive sense of the top chart (or the 4-2-1 rule). You convert each octal digit back into its component three binary digits to get your final value.

Octal to Binary: https://circuitglobe.com/octal-to-binary-and-binary-to-octal-conversion-methods.html
Binary and Hexadecimal:
Source: https://owlcation.com/stem/How-to-Convert-Hex-to-Binary-and-Binary-to-Hexadecimal
Hexadecimal relies on the very same principle as octal except with groups of four binary digits instead of three (thereby creating an 8-4-2-1 rule). The system adds extra digits A (10), B (11), C (12), D (13), E (14), F (15). I've added the decimal equivalents because it makes it easier to understand what they represent. This four-digit system allows for manual conversion forwards and backwards as with the previous system.

Extra Sources
https://www.researchgate.net/post/Why_do_we_need_various_number_base_conversions_number_system_conversions_eg_octal_to_hexadecimal2


Text Symbols

by 12:47 PM
This is an extended version of another user's text symbol sheet.

Ex. Symbol (to test copying/pasting): 囧

Lines:
┌ ┍ ┎ ┏ ┐ ┑ ┒ ┓ └ ┕
┖ ┗ ┘ ┙ ┚ ┛ ├ ┝ ┞ ┟
┠ ┡ ┢ ┣ ┤ ┥ ┦ ┧ ┨ ┩
┪ ┫ ┬ ┭ ┮ ┯ ┰ ┱ ┲ ┳
┴ ┵ ┶ ┷ ┸ ┹ ┺ ┻ ┼ ┽
┾ ┿ ╀ ╁ ╂ ╃ ╄ ╅ ╆ ╇
╈ ╉ ╊ ╋ ╌ ╍ ╎ ╏ ═ ║
╒ ╓ ╔ ╕ ╖ ╗ ╘ ╙ ╚ ╛
╜ ╝ ╞ ╟ ╠ ╡ ╢ ╣ ╤ ╥
╦ ╧ ╨ ╩ ╪ ╫ ╬

Arrows:
⏎ ➟ ➡ ➢ ➣ ➤ ➥ ➦ ➧ ➨
➚ ➘ ➙ ➛ ➜ ➝ ➞ ➸ ♐ ➲
➴ ➵ ➶ ➷ ➸➹ ➺ ➻ ➼ ➽
← ↑ → ↓ ↔ ↕ ↖ ↗↘ ↙
↚ ↛ ↜ ↝ ↞ ↟ ↠ ↡ ↢ ↣ ↤
↥ ↦ ↧ ↨ ➫ ➬ ➩ ➪ ➭ ➮ ➯ ➱
↩↪ ↫ ↬ ↭ ↮ ↯ ↰ ↱ ↲ ↳ ↴ ↵
↶↷ ↸ ↹ ↺ ↻ ↼ ↽ ↾ ↿ ⇀ ⇁ ⇂ ⇃
⇄ ⇅ ⇆ ⇇ ⇈ ⇉ ⇊ ⇋ ⇌ ⇍ ⇎ ⇏
⇐⇑ ⇒ ⇓ ⇔ ⇕ ⇖ ⇗ ⇘ ⇙ ⇚ ⇛
⇜ ⇝⇞ ⇟ ⇠ ⇡ ⇢ ⇣ ⇤ ⇥ ⇦ ⇧ ⇨ ⇩ ⇪

Zodiac:
♈ ♉ ♊ ♋
♌ ♍ ♎ ♏
♐ ♑ ♒ ♓

Shapes:
◉ ○ ◌ ◍ ◎ ● ◐
◑ ◒ ◓ ◔ ◕ ◖ ◗
❂ ☢ ⊗ ⊙ ◘ ◙ ◍

Chess:
♔ ♕ ♖ ♗ ♘ ♙
♚ ♛ ♜ ♝ ♞ ♟

Cards:
♤ ♧ ♡ ♢
♠ ♣ ♥ ♦

Bubble Numbers and Letters
Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ

ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ⓠ ⓡ ⓢ ⓣ ⓤ ⓥ ⓦ ⓧ ⓨ ⓩ

➀ ➁ ➂ ➃ ➄ ➅ ➆ ➇ ➈ ➉

➊ ➋ ➌ ➍ ➎ ➏ ➐ ➑ ➒ ➓

Fingers:
☜ ☞ ☝
☚ ☛ ☟
✍ ✌

Weather:
☼ ☀ ☁ ☂ ☔
☄ ☾ ☽ ❄ ☃
☈ ⊙ ☉ ℃ ℉
° ❅ ✺ ϟ ☇

Faces:
☹ ☺ ☻ ت
ヅ ツ ッ シ
Ü ϡ ﭢ

Stars:
⋆ ✢ ✣ ✤ ✥ ❋
✦ ✧ ✩ ✰ ✪ ✫
✬ ✭ ✮ ✯ ❂ ✡
★ ✱ ✲ ✳ ✴
✵ ✶ ✷ ✸ ✹
✺ ✻ ✼ ❄ ❅
❆ ❇ ❈ ❉ ❊

Letters

A: Ⱥ Д ∆ ₳Ꭿ Ꭺ
B: ℬ Ᏸ 乃 ط ъ
C: 匚 ང Ꮳ ℂ
D: ƌ Ꭰ Ꮄ ⅅ ⅆ
E: ε ཇ Σ Ξ Ꭼ Ꮛ ⅇ
F: ན ƒ
G: Ꮹ ɠ ʛ Ꮆ Ᏻ
H: ħ ℌ Ꮋ Ꮒ Ᏺ ℍ
I: ༏ ༑ ༐ ⅈ Ꮠ
J: \uD840\uDCCC Ꭻ Ꮰ ℑ ⅉ
K: ƙ
L: ℒ Ꮮ ɭ Ꮭ ℓ ﷼
M: ཀ Ꮇ ᙢ ℳ
N: ₪ ת מ ה ས π ℵ
O: Ꮎ
P: ρ や 尸 Ꮅ
Q: Ꭴ
R: ર ℜ ཞ ༉ Ꭱ
S: Ꭶ
T: τ Ꮖ ϯ ד Ꮏ ե Ꭲ
U: Ꮜ
V: Ꭷ Ꮴ
W: Ꮤ ᙡ Ꮚ ש ཡ ш щ ϣ Ꮗ
X: ℵ א ж
Y: ע ч ɤ ɣ Ꮍ
Z: Հ ʑ Ꮓ ℤ

Extended Letters
A a à á â ä æ ã å ā Ⓐ ⓐ ɐ ɑ ɒ ∀ ∆ ∢ Գ Ճ ձ ਚ Д Ѧ ѧ Ѩ ѩ Ӑ ӑ Ӓ ӓ ӕ მ Λ ά α Ά ઊ ה ם À Á Â Ã Å Ā Ą ą Æ இ ค จ ถ อ ๙ ཐ བ Ꮜ Ꮑ Ꭺ Ꭿ ◬ ▵ ⋒ ⍶ ⍲ ⍱ ⍝ ⍙ ⍫ ⍺

ʙ ʚ ɮ ɞ ɓ ც Β βϐ ß Ɓ ƀ Ƅ ƅ ƃ Ƃ ฿ ๖ ธ ઉ Ь в ъ ь Ѣ ѣ Ҍ ҍ ճ B b ъႦႪ ს წ ც ხ ჱ ઇ Ḇ Ḃ Ḅ ḃ ḇ ḅ ß Ɓ ƃ Ƃ ℬ Ᏼ Ᏸ Ⓑ ⓑ

Ⓒ ⓒ C c Ç Ć ℂ ℃ ɔ ʗ ∁ ⊏ ⋐ ₠ ₡ ₢ ¢¢с Ҫ ҫ ე Ϛ ϲ Ç ç ć Ĉ ĉ Ċ ċ Č č Ḉ ḉ Ƈ Ɔ ƈ ༊ ང ༨ ℂ Ꮸ Ꮯ € ℭ ⊂

Ⓓ ⓓ ɖ ɗ ʠ ʣ ʤ ʥ ᵈ ժ ծ ձ ճ ԁ Ԁ მ ძ δ ઠ વ Ď ď Đ Ḋ Ḍ Ḏ Ḑ ḋ ḏ ḍ ḑ ḓ Ḓ Ð ð Ɖ Ɗ ƌ ƿ DŽ Dž dž DZ Dz dz ฎ ๔ ⅆ ⅅ Ꮷ Ꭰ

Ⓔ ⓔ ℇ ℈ ℮ ℯ ℰ ɘ ə ɚ ɛ ɜ ɝ ʓ ʒᵉ ∃ ∄ ∈ ∉ ∊ ∌ ∋ ∍ ∑ ≡ ≆ ≋ ≇ ۼ ੬ ੩ Ѐ Ё Е Ш ѐ ё є Ҙ ҙ Ҽ ҽ Ҿ ҿ Ӗ Ӛ ӗ Ә ӛ Ӡ ӡ Ӭ ӭ Ԑ ԑ ६ ჳ ჴ Ε Ξ Σ έ ε ξ Έ દ ૩ c ૬ ૯ È è É é Ê ê Ë ë Ē ē Ĕ ĕ Ė ė Ę ę Ě ě Ȩ ȩ Ȅ ȅ Ȇ ȇ Ḕ ḕ Ḗ ḗ Ḙ ḙ Ḛ ḛ Ḝ ḝ Ẹ ẹ Ẻ ẻ Ẽ ẽ Ế ế Ề ề Ể ể Ễ ễ Ệ ệ Ǝ Ƹ ƹ Ǯ ǯ ༣ ཇ ཛ ཟ ℰ ⅇ ⅀ € Ꮛ Ꭼ

Ⓕ ⓕ ℉ ℱ ɟ ʄ ʆ∮ ∲ ∯ ∳ ∱ ⊧ ⊫₣ ƒ Բ բ Ғ ғ Ϝ Ḟ ḟ ẛ Ƒ ƒ ƭ F


Funky Letters
ჲ ჳ ხ Ꭰ Ꭱ Ꭲ Ꭳ Ꭴ Ꭵ Ꭶ Ꭷ Ꭿ Ꭾ Ꭽ Ꭼ Ꭻ Ꭺ Ꭹ Ꭸ Ꮀ Ꮁ Ꮂ Ꮃ Ꮄ Ꮅ Ꮆ Ꮇ Ꮈ Ꮉ Ꮊ Ꮋ Ꮌ Ꮍ Ꮎ Ꮏ Ꮐ Ꮑ Ꮒ Ꮓ Ꮔ Ꮖ Ꮕ Ꮗ Ꮘ Ꮙ Ꮚ Ꮛ Ꮜ Ꮝ Ꮞ Ꮟ Ꮠ Ꮡ Ꮢ Ꮣ Ꮤ Ꮥ Ꮦ Ꮧ Ꮨ Ꮩ Ꮪ Ꮫ Ꮬ Ꮭ Ꮮ Ꮯ Ꮰ Ꮱ Ꮲ Ꮳ Ꮴ Ꮵ Ꮶ Ꮷ Ꮿ Ꮾ Ꮽ Ꮼ Ꮻ Ꮺ Ꮸ Ᏸ Ᏹ Ᏺ Ᏻ Ᏼ ἡ ₧ ₴ € ₪ ₤ ℂ ℋ ℌ ℎ ℏ ℐ ℑ ℒ ℓ ℕ ℗ ℘ ℙ ℚ ℛ ℜ ℝ ℞ ℤ
Ⴓ ℟ ☈ Ƨ Է Д
℥ ℨ ℬ ℰ ℱ Ƒ ℳ ℵ ℸ ℹ ⅅ ℽ ℼ ⅆ ⅇ ⅀ ⅊ ⅉ ⅈ ʑ ʐ ʋ ɠ ɕ ۷۩ღ жӿ ñ˜

Regular Letters:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

a b c d e f g h i j k l m n o p q r s t u v w x y z

Funky Faces

^◡^
≧◔◡◔≦
|(• ◡•)|
☜(˚▽˚)☞
ಥ_ಥ
( つ﹏╰)
(っ◔‿◔)っ
♡ (♥,♥)
(◡‿◡✿)
ύ.ὺ
(ノಠ益ಠ)ノ
凸(¬‿¬)
(◣◢)
┌∩┐
(◐.̃◐)
Ƹ̴Ӂ̴Ʒ
╰☆╮
(>‿◠)

Mathematical Signs
+ - * /
% $ ()
⅟ ½ ⅓
¾ ⅔ ⅕
⅖ ⅗ ⅘
⅙ ⅚ ⅛
⅜ ⅝ ⅞

*Repeats may be seen

Credit to Babissimo for the original concept

Lemoine's Conjecture Verified to 10^10

by 12:05 PM
The mathematician who first thought of this idea: Emile Lemoine
Lemoine's conjecture, sometimes referred to as Levy's conjecture, states that all odd numbers can be broken into the sum of an odd prime and an even semi-prime.

Here are three examples of "lemoine partitions", i.e. where the odd numbers are broken down into their constituent elements based on the definition above.
$$7 = 3 + 2 * 2$$
$$9 = 3 + 2 * 3$$
$$11 = 5 + 2 * 3$$
In 1999, Dann Corbit was able to verify the conjecture to 1,000,000,000 numbers utilizing the following code in C (https://groups.google.com/forum/?hl=en#!msg/sci.math/HoCpH8gPDHM/gtU-fuSWnFMJ):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define TEST( f, x ) ( *( f+( x )/16 )&( 1<<( ( ( x )%16L )/2 ) ) )
#define SET( f, x ) *( f+( x )/16 )|=1<<( ( ( x )%16L )/2 )

unsigned        ip(unsigned long j, unsigned char *d)
{
    if (j == 1)
        return 0;
    if ((j % 2) == 0) {
        if (j == 2)
            return 1;
        else
            return 0;
    } else
        return (!(*(d + (j) / 16) & (1 << (((j) % 16L) / 2))) && j != 1);
}

int             main(int argc, char *argv[])
{
    unsigned char  *feld = NULL,
    *zzz = NULL;
    unsigned long   teste = 1,
    max,
    mom,
    hits = 1,
    alloc;
    time_t          begin;
    unsigned char   quiet = 0;
    if (argc > 1) {
        max = atol(argv[1]) + 10000;
        if (argc > 2)
            quiet = 1;
    } else
        max = 1000000000L;
    
    zzz = feld = malloc(alloc = (((max -= 10000L) >> 4) + 1L));
    if (feld) {
        char            found;
        memset(zzz, 0, alloc);
        printf("Searching prime numbers to : %lu\n", max);
        begin = time(NULL);
        while ((teste += 2) < max)
            if (!TEST(feld, teste)) {
                ++hits;
                for (mom = 3L * teste; mom < max; mom += teste << 1)
                    SET(feld, mom);
            }
        printf(" %ld prime numbers found in %.2f secs.\n\n",
               hits, difftime(time(NULL), begin));
        {
            long            o,
            p,
            q,
            j;
            for (o = 7; o <= max; o += 2) {
                found = 0;
                for (j = 2; j < o;) {
                    p = j;
                    q = o - 2 * p;
                    if (ip(p, feld) && ip(q, feld)) {
                        if (!quiet)
                            printf("%lu = 2*%lu + %lu\n", o, p, q);
                        found = 1;
                        break;
                    }
                    if (j == 2)
                        j++;
                    else
                        j += 2;
                }
                if (!found)
                    printf("*** Problem!! %lu\n", o);
            }
            
            free(feld);
            printf(" Finished calculations in %.2f secs.\n\n",
                   difftime(time(NULL), begin));
        }
    } else {
        puts("Memory allocation failure.");
        exit(EXIT_FAILURE);
    }
    return 0;
}

A new verifier was implemented in Python to try and either match/exceed this number.

"""
Description: Traditional Implementation of Lemoine's Conjecture
"""

import numpy as np
import time

def primesfrom2to(n):
    # https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = np.ones(n/3 + (n%6==2), dtype=np.bool)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      ((k*k)/3)      ::2*k] = False
            sieve[(k*k+4*k-2*k*(i&1))/3::2*k] = False
    return np.r_[2,3,((3*np.nonzero(sieve)[0]+1)|1)]

def main():
    start_time = time.time()
    n = 7
    x = 0
    l = list(primesfrom2to(1000000000))
    sl = set(l)
    print("Done")
    print("--- %s seconds ---" % (time.time() - start_time))            

    while (n < 1000000000):
        if(n-(2*l[x]) in sl):
            n = n+2
            x = 0
        x = x + 1
    print("Done 2")  
    print("--- %s seconds ---" % (time.time() - start_time))            
    
main()

This version relied on a pre-generated list of prime numbers in both list and set form to generate odd numbers sequentially. It rearranges the formal definition of Odd # = 2q + p to Odd # - 2q = p to take advantage of python's native set data type and enhanced searching capabilities. Replacing these with just lists, numpy arrays, or iterators was considered but not successfully implemented in a time-conserving manner.

You can track the progress of the generator by inserting this code snippet within the if statement within the while loop within the main method.

if n % 1000 == 1:
                print("\r{}/{}".format(n, 100000))

Here is a table with the speed results from this implementation. The program reached 2*10^9 before stressing the hardware due to lack of available memory.

Odd #’s up to ___ checked
Time
10,000
--- 0.0129 seconds ---
100,000
--- 0.129 seconds ---
1,000,000
--- 1 seconds ---
10,000,000
--- 11 seconds ---
100,000,000
--- 138 seconds ---
1,000,000,000
--- 1593 seconds ---
2,000,000,000
--- 3,487 seconds ---

Another approach would be to generate the results from all of the combinations of p + 2q and match those up to a list of the odd numbers greater than or equal to seven. This was implemented with the following program.

"""
Description: New strategy to tackle verifying Lemoine's conjecture
"""

import numpy as np
import time
from operator import add

def primesfrom2to(n):
    # https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = np.ones(n/3 + (n%6==2), dtype=np.bool)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      ((k*k)/3)      ::2*k] = False
            sieve[(k*k+4*k-2*k*(i&1))/3::2*k] = False
    return np.r_[2,3,((3*np.nonzero(sieve)[0]+1)|1)]

def cartesian_add(arr1, arr2):
    arr1_e = np.repeat(np.expand_dims(arr1, 1), arr2.size, axis=1)
    arr2_e = np.repeat(np.expand_dims(arr2,  0), arr1.size, axis=0)
    return arr1_e + arr2_e

def main():
    start_time = time.time()
    list1 = primesfrom2to(1000000)
    list2 = 2 * list1
    list4 = np.arange(7,3000000,2)
    list4 = np.setdiff1d(list4,np.unique(cartesian_add(list1, list2)))
    print(list4)    
    print("--- %s seconds ---" % (time.time() - start_time))
  
main()

While the original versions of this implementation utilized nested for loops (later changed to for loop containing a map(add,primes,semiprimes) function with rolling numpy primes loop), Ernie Parke contributed the cartesian_add method which shaved off several seconds (it runs about 4x faster without the use of the np.unique function than the original implementation).

The cartesian_add function essentially generates all of the combinations of addition while the set.diff1d function figures out which numbers are only a part of the set of odd numbers (originally represented as list4) and therefore haven't been verified.
Schematic of the principle utilized in the "new strategy." Source
Nevertheless, this version was able to only check 100,000 numbers in approx. five seconds which was much slower when compared to the original implementation (see the table above).

Jacob G. of Futuresight Technologies also developed a C++ code to to verify Lemoine's conjecture for a certain number of digits. Please note that it requires -fopenmp flag if you want to utilize the parallelism within the program to decrease run-time.

#include <iostream>
#include <vector>
#include <set>

typedef unsigned long long ull;

using namespace std;

const ull maxNumber = 1000000000;

bool numberWorks(ull n, vector<ull>& primes, set<ull>& primeSet) {
    ull factor;
    ull remainder;
    ull primeSize = primes.size();
    ull semiPrime;
    for (ull i = 0; i < primeSize; i++) {
        factor = primes[i];
        if (factor > n) {
            return false;
        }
        remainder = n - factor;
        
        if (remainder % 2 == 0 && primeSet.find(remainder / 2) != primeSet.end()) {
            return true;
        }
    }
    return false;
}

int main() {
    bool* primes = new bool[maxNumber];
    bool* semiPrimes = new bool[maxNumber];
    
    vector<ull> primeList;
    set<ull> primeSet;
    
    for (int i = 0; i < maxNumber; i++) {
        primes[i] = true;
    }
    
    for (int i = 2; i < maxNumber; i++) {
        if (primes[i]) {
            for (int j = i; j < maxNumber; j += i) {
                primes[j] = false;
            }
            primeList.push_back(i);
            primeSet.insert(i);
        }
    }
    cout << "Computed primes!" << endl;
    
    #pragma omp parallel for num_threads(8)
    for (ull numberToCheck = 7; numberToCheck < maxNumber; numberToCheck += 2) {
        if (!numberWorks(numberToCheck, primeList, primeSet)) {
            cout << "Number failed: " << numberToCheck << endl;
        } else if ((numberToCheck - 1) % 1000000 == 0) {
            cout << (numberToCheck / (double)maxNumber) * 100 << "%" << endl;
        }
    }
    
    delete[] primes;
    delete[] semiPrimes;
}

He contributed the following speed readings:

Odd #’s up to ___ checked
Time
1,000,000
--- .6 seconds ---
10,000,000
--- 15 seconds ---
100,000,000
--- 301 seconds ---

Out of curiosity, the original C code was run again to see how efficient it was. Due to C being a compiled language, this test ended up being more successful than the python programs at and allowed the conjecture to be verified to 10^10 in a reasonable time period. Here are some times for those runs:

Odd #’s up to ___ checked
Time
1,000,000,000
--- 108 seconds ---
10,000,000,000
--- 1009 seconds ---

Therefore, it is concluded that the conjecture is now verified up to 10^10 through the original C code, and up to 2*10^9 through the new Python implementation.

Thank you to Ernie Parke and Jacob G. answering all of my questions throughout this process. 

Sources:
https://en.wikipedia.org/wiki/Lemoine%27s_conjecture
http://mathworld.wolfram.com/LevysConjecture.html
https://planetmath.org/levysconjecture
https://primes.utm.edu/curios/page.php?number_id=82&submitter=Capelle
https://www.mathsteacher.com.au/year7/ch11_ratios/04_prob/unit.htm
https://oeis.org/A046927

The Lewis Dot Structure for HCN

by 11:03 AM
Created by MakeTheBrainHappy

The molecule HCN has one of the most fascinating lewis structures. It is one of the few which features a nitrogen triple bond. It is possible to draw the structure with two electrons in place of the lines to represent the covalent bonds, which would result in there being six shared electrons between the carbon and nitrogen. We know that hydrogen can only share one bond with the carbon as we looked at in a previous article. Hydrogen essentially only needs two valence electrons to fill its outer shell because it only has a 1s orbital. The carbon, based on its position in the periodic table, has four electrons to share which it does with the nitrogen. The total number of "shared" electrons equals eight, filling carbon's valence shell. The nitrogen's "shared electron" count is six, which means that it needs two more electrons to fill its shell which is accounted for by the lone pair. Furthermore, this brings the total number of electrons on nitrogen to five as the periodic table predicts. 

HCN has a linear geometry but unlike nonpolar CO2 is polar due to the intrinsic electronegativity on nitrogen and the stronger force by Coulomb's law pulling on the electrons in the triple bond creating a more negative bent on the right (based on the diagram) than the left. This means that it undergoes dipole-dipole interactions not unlike water (h2o). Water's intermolecular bonds are considered to be stronger hydrogen bonds (H-F, H-N, H-O bonds) due to these having the largest electronegativity difference. By this logic, HCN dipole-dipole interactions are also weaker the intramolecular bonds in network covalent solids. Nevertheless, these stronger intermolecular forces contribute to its boiling point at room temperature, or approximately 26˚C.
Structure of HCN from Wikimedia Commons. Source

While HCN is produced as a precursor to many molecules and chemicals, the compound itself is extremely flammable and poisonous. It can be produced by combining hydrogen chloride (HCl) and Sodium Cyanide (NaCN). Often described as a pale or blue colorless liquid, it has a distinctive scent that will warn those of its toxicity. Furthermore, it is a weak acid that partially ionizes in water. 

HCN's structure also features an sp hybridized structure with 180˚ of difference between the two molecules on the end. The triple bond contains one sigma bond and two pi bonds. Such a simple molecule can in the end still contain more complex chemistry.

Source:



Primitive Data Types in Java

by 6:20 PM
Graphic with the eight primitive data types by MakeTheBrainHappy.
Data in computer science, especially in Java, it defined with a type that defines the type of data that can be stored (words, numbers, etc.) and the range of values (i.e. length of the words or size of numbers, etc.) that can be acted upon.

Primitives are built-in data types; other types are "reference" types that need to be defined in a class blueprint and "created" as objects. Primitives are simpler and will allow us to begin our discussion of data. Java has eight primitive data types (the three most common are starred):

Byte: integer value (8 bits)

Short: integer value (16 bits)

*Int: integer value (32 bits)

Long: integer value (64 bits)

Float: floating point # (32 bits)

*Double: floating point # (64 bits)

Character: one unicode character

*Booleans: a true or false value

A larger number of bits corresponds to a larger number which can be stored into those variables.

Declaring Primitives:

byte varName;
short VarName;
int varname;
long Varname;
float vArname;
double vArName;
char varNAme;
boolean varNAMe;

These variables can be then be assigned using the = operator to values fitting the descriptions for each of the primitive data types. If you add the keyword final between the type and variable name, then you have declared a constant (you cannot change the data within the variable later in the program).

Reserved Keywords:

Java has certain reserved keywords that cannot be utilized as variable names due to their special functions within the language. These are abstract, assert, boolean, break, byte, case, catch, char, class, const, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package,  private, protected, public, return, short, static, strictfp, super, switch, synchronized,  this, throw, throws, transient, true, try, void, volatile, while, and continue.

Visibility Modifiers:

Variables can either be declared as public or private, reserved keywords which are placed in front of the type. Public variables can be accessed by all classes while private variables can only be utilized by the class in which they are declared.

Static vs. Non-Static Variables:

This keyword, also placed before the type but after the visibility modifier, determines whether the variable is a part of the object declared from the class (thereby only being accessible through the identifiers of an object) as opposed to static variables are a part of the class and therefore can be accessed from "static" contexts such as the main method or static methods.

Casting

Some variables can be changed from one type to another through casting. Between the six types dealing with numerical values, you can cast utilizing the casting operator placed before the variable name. For example, here is a variable being converted from a integer to a double.


int varname = 1;
double newDouble = (double)varname;

This is a widening conversion since a more restrictive data type is changed to a more free version; therefore, no data is lost. But if you are converting a double to an integer, you would lose the information encoded by the decimals. This means that this would be a narrowing conversation.

Numerical Methods: Estimating Integrals and the Trapezoidal Rule

7:46 PM
The magnitude of an integral in 2D can be geometrically interpreted as the area bounded by y=f(x) and the independent variable x between an interval set by x. The positivity/negativity of the resulting integral is determined by how much area is over/under the x-axis such that any area over the x-axis adds to the value of the integral, and vice-versa. Thus, using basic geometry we are able to estimate/determine the value of an integral using common area formulas we already know, even integrals whose answer cannot be represented by elementary functions.

Many methods to estimate the area under a function evaluates the integral of simpler sub-curves that resembles the original function. Essentially, the curve is broken up into different sub-intervals and a simpler curve that estimates the original curve is created for each sub-interval. The curves made are generally a polynomial since polynomials are easy to integrate. Then, the integral of sub-curve in each sub-interval is evaluated and summed together. The result is an approximation of the integral of the entire curve.

Some notable and widely used methods include the Riemann sum which uses horizontal lines to estimate the integral, trapezoidal rule which use lines, and Simpson's 1/3 and 3/8 rule which uses degree two and three polynomials, respectively. It is important to note that estimating the integral of the overall curve then boils down to the integration of the sub-curves. If the area bounded by the sub-curve in each sub-interval and the x-axis is a simple shape (i.e. rectangles for the Riemann sum or polygons for the trapezoidal rule) then the integral of each sub-curve can be geometrically represented by such area.

Figure 1: The area under the curve in black is approximated using the (left) Riemann sum (in red), trapezoidal rule (in yellow) and the Simpson's 1/3 rule (in green). Note the number of sub-intervals in this case is two, and each different method uses different polymeric curves to resemble the shape of the original curve.
In figure 1 it is evident that the maximum error of the estimate decreases as we increase the degree of the polynomial used to estimate the curve. It is also the case that the larger the amount of sub-intervals, the smaller the maximum error. These properties are generally true for any function.

The Trapezoidal Rule

The trapezoidal rule is one of the easiest methods to estimate the value of an integral. It uses lines to approximate the shape of a curve. Then, the integration of all such lines results in an estimation. The trapezoidal rule is also simple to use since the equations are simple and the number of sub-intervals chosen does not have additional restrictions other than being positive (e.g. Simpson's 1/3 rule requires the number of sub-intervals to be even).

Figure 2: Graphical explanation of the trapezoidal rule: two sub-intervals $[x_0,x_1]$ and $[x_1,x_2]$ are created as $n=2$. A line is drawn from $f(x_0)$ to $f(x_1)$ and from $f(x_1)$ to $f(x_2)$. The sum of the integral of the lines (shaded in yellow) gives the estimated value of the function's integral. 

Derivation

We briefly discuss a geometric derivation of the trapezoidal rule. Suppose we have an integral that spans from $x_0=a$ to $x_n=b$. We assume the function is continuous over the interval. We can partition such interval $[a,b]$ into $n$ smaller sub-intervals such that $a = x_0 \lt x_1 \lt \dots \lt x_i \lt \dots \lt x_{n-1} \lt x_n=b$. Define $\Delta x_i$ to be $x_i - x_{i-1}$. For each sub-interval $[x_{i-1},x_i]$ if $f(x_i)$ and $f(x_{i-1}) \geq 0$ then the integral is given by the area bounded by the curve and x-axis in the interval. The curve in the sub-interval is estimated to be a linear line between the bounds of the sub-interval evaluated at the function. Thus, the area bounded by the line and the x-axis in the interval is determined to be $$I_i \approx \frac{f(x_i)+f(x_{i-1})}{2}\Delta x_i \label{eq:1} \tag{1}$$
For $f(x_i)$ and $f(x_{i-1}) \leq 0$ the integral is estimated using the same method as above, and is the negative of the area. Thus it is $-\frac{|f(x_i)+f(x_{i-1})|}{2}\Delta x_i$. This equals to equation \ref{eq:1} since $f(x_i)$ and $f(x_{i-1}) \leq 0$. If $f(x_i)$ and $f(x_{i-1})$ have opposing signs, we can further break up the sub-interval. There only exists one point $x_k$ where $f(x_k)=0$ due to the intermediate value theorem and the fact that a line can only pass the x-axis once or an infinite amount of times. The estimated integral of the function in $[x_{i-1},x_i]$ is determined to be:
\begin{align*}I_i &\approx \frac{f(x_k)+f(x_{i-1})}{2}(x_k-x_{i-1})+\frac{f(x_i)+f(x_k)}{2}(x_i-x_k)\\
&=\frac{f(x_{i-1})}{2}(x_k-x_{i-1})+\frac{f(x_i)}{2}(x_i-x_k)\\\end{align*}By similar triangles we see that $x_k-x_{i-1}=-\frac{f(x_{i-1})\Delta x_i}{f(x_i)-f(x_{i-1})}$ and $x_i-x_k=\frac{f(x_i)\Delta x_i}{f(x_i)-f(x_{i-1})}$ so
\begin{align*}I_i &\approx -\frac{f^2(x_{i-1})}{2(f(x_i)-f(x_{i-1}))}\Delta x_i+\frac{f^2(x_i)}{2(f(x_i)-f(x_{i-1}))}\Delta x_i\\
&=\frac{f^2(x_i)-f^2(x_{i-1})}{2(f(x_i)-f(x_{i-1}))}\Delta x_i\\
&=\frac{f(x_i)+f(x_{i-1})}{2}\Delta x_i\\\end{align*}
Therefore regardless of the nature of the function in any sub-interval, the integral in $[x_{i-1},x_i]$ is estimated to be equation \ref{eq:1}.
The integral of the overall curve in the interval $[a,b]$ is the sum of all the estimated integrals in each sub-interval, explicitly:
$$I = \sum_{i=1}^{n} I_i$$
$$I \approx \sum_{i=1}^{n} \frac{f(x_{i-1})+f(x_{i})}{2}\Delta x_i \label{eq:2} \tag{2}$$

If the sub-intervals are evenly spaced, then
$$I \approx \frac{b-a}{2n}\sum_{i=1}^{n} \big(f(x_{i-1})+f(x_i)\big)$$
$$I \approx \frac{b-a}{2n} \bigg(f(x_0)+f(x_n)+2\sum_{i=1}^{n-1} f(x_{i})\bigg) \label{eq:3} \tag{3}$$

Equations \ref{eq:2} and \ref{eq:3} are the final forms used in this numerical method.

Implementation

Implementation of the trapezoidal rule is relatively straightforward. One thing to note is that the higher the number of sub-intervals, the better the accuracy however it is important to realize that the higher the number, the more prominent round-off errors get. Generally the round-off errors associated to this method are negligible assuming the number of intervals don't get ridiculously large. It is recommended to calculate and use the minimum number of sub-intervals to achieve a desired maximum error using this formula. Then as the integration bounds change, it is generally recommended to triple the number of sub-intervals for the doubling of the integration interval; this will keep the maximum error relatively the same assuming the maximum concavity of the function in the new interval change stays constant compared to the old one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
function f(x)
return math.sin(x)/x
end

a=1 --lower bound
b=3 --upper bound
n=5000 --number of sub-intervals

sum=0
for i=1,n do
xi=((b-a)*i/n)+a
xi1=((b-a)*(i-1)/n)+a
sum=sum+(f(xi)+f(xi1))*((b-a)/(2*n))
end

print(sum)
Figure 3: Lua code for the implementation of the trapezoidal rule. Note the estimation of a non-elementary integral sin(x)/x.


Exercises

  1. Using the error formula for the trapezoidal rule what is the equation that gives the maximum possible error for the integral $\int^{x}_{0} t^3+e^{t}~dt$ using $n$ equal sub-intervals? What is the formula for the exact error?
  2. Prove that the trapezoidal rule, for any number of sub-intervals greater or equal to 1,
    1. overestimates a parabola's integral if it faces upward.
    2. perfectly estimates the integral for functions of the form $y=ax+b$.
  3. Use the trapezoidal rule with $n=4$ to estimate $\int_{0}^{5}5x-5~dx$.
  4. Estimate the integral from $\pi$ to $2\pi$ of $\frac{\sin(x)}{x}$ with the minimum number of sub-intervals such that the maximum error is no more than 0.05.
  5. For batch/simple distillation where a binary liquid mixture is boiled and condensed into a receiving flask, the equation $\ln\Big(\frac{W}{F}\Big)=-\int_{x_w}^{x_f}\frac{dx}{y-x}$ is important to quantify the ending amounts of liquid in both containers and its respective concentrations. $x$ is related to $y$ as provided in the table below:
  6. Figure 4: Table of values for question 5.
    If $x_w=0.02, x_f=0.20$, and $F=1$, estimate $W$, the remaining liquid in the feed pot in mols. [1]
  7. Derive equation \ref{eq:1} using
    1. a geometric approach.
    2. a mathematical approach.
  8. Using one sub-interval with the trapezoidal rule to estimate certain functions is sometimes more accurate than using two or more intervals. Provide a function that shows this.
  9. Refer to Figure 1 and identify the numerical method that estimates the integral
    1. the most poorly?
    2. the most accurately?
    3. the quickest, if calculated manually?
    4. the slowest, if calculated manually?
  10. Refer to the equation \ref{eq:3} and the equation directly above it. Why is it more efficient to use equation \ref{eq:3} rather than the other one, especially when manually evaluating the formula?
  11. We've seen different methods that can be used to estimate the integral of a curve. The ones mentioned use polynomials of varying degrees to resemble the shape of the original curve. Referring to Figure 5 and considering all the methods presented in this article, which method would be the best (efficiency and accuracy wise) at estimating the integral of the functions from $x=1$ to $x=5$? For each function,
    1. is equation \ref{eq:2} or \ref{eq:3} more useful?
    2. how many sub-intervals would you choose?
    3. where would you partition the sub-intervals?
Figure 5: Question 10 graphs - which method would be the best (efficiency and accuracy wise) at estimating the integral of the following functions?

[1] Question adapted from Prof. R. Pal from the University of Waterloo, Ontario.

Images belong to KrIsMa. HTML code format generated using hilite.me.

ALIRA Unofficial Practice Test 1

by 8:30 AM
The ALIRA Test is a reading comprehension test for Latin with a variety of passages ranging from historical narratives to modern articles. Scores are measured on a range from N1-5 to A with I1-5 in between. You can see a sample score report here. The Language Testing International Organization has released a practice exam, available here. This practice exam is based on the structure of the official sample test, providing those interested with unofficial materials to study with. The questions generally increase in difficulty as you move through the texts and are taken from a wide range of sources. Currently, there is no way to assess the level of each question, but generally the first questions are equivalent to novice levels and the final questions are equivalent to the intermediate levels. Good Luck!


Source: Lingua Latīna Per Sē Illūstrāta Pars I: Familia Rōmāna


Which of the following would the ships trade with?
A.) Oppidum
B.) Fluvius
C.) Insula
D.) None of the Above

The image above is related to
A.) Funerals
B.) Schools
C.) Marriages
D.) Economics


Source: Wheelock’s Sixth Edition


Whom is Martial addressing?
A.) Himself
B.) Fidentius
C.) a Male
D.) Recitas


“In primis annis Romani habuerunt reges. Reges fuerunt Etrusci. Etrusci erant in throno Romano.”
Source: Latin by the Natural Method
Who ruled Rome?
A.) The Romans
B.) The Etruscans
C.) Roman Kings
D.) Etruscan Kings


Source: The Latin Wikipedia News Page


What happens to the Capital?
A.) The citizens recreate it like it was in 1991
B.) The president gave an address in Astana
C.) The capital city was renamed to “Nursultan”
D.) The president left office.


Source: Western Washington University


What is the origin of the cold air?
A.) Canada
B.) Mississippi
C.) Louisiana
D.) Georgia




What is going on in this passage?
A.) The Roman Senate debates going to war with Carthage
B.) The Carthaginian Senate debates going to war with Rome
C.) The Carthaginian Senate discusses the command of Hasdrubal
D.) The Carthaginian Senate discusses the command of Hannibal


Source: Via Latin; An Easy Latin Reader


Why did Pelias wish to kill Jason?
A.) He wanted to become king
B.) He felt that Jason was a danger to the Kingdom
C.) He had abducted the king
D.) He didn’t.


Source: A First Latin Reader (1912)


What prevented Columbus from traveling on the sea?
A.) Family Obligations
B.) Money
C.) Care
D.) Danger


Source: Fabulae Facilis


What did Laomedon not wish to do?
A.) Be in the favor of Neptune and Apollo
B.) Pay for the services of Neptune and Apollo
C.) Ask Neptune and Apollo for good fortune
D.) Increase tribute to Neptune and Apollo


Eo nomine senatus decretis honorificis in ordinem suum me adlegit, C. Pansa et A. Hirtio consulibus, consularem locum sententiae dicendae tribuens, et imperium mihi dedit. Res publica ne quid detrimenti caperet, me propraetore simul cum consulibus providere iussit. Populus autem eodem anno me consulem, cum cos. uterque bello cecidisset, et triumvirum rei publicae constituendae creavit. - Octavian
Source: Res Gestae Divi Augusti


With what rank did Octavian gain imperium?
A.) Tribune
B.) Propraetor
C.) Consulship
D.) Triumvir

Answer Key (highlight it): 1.) A 2.) B 3.) B 4.) D 5.) C 6.) A 7.) D 8.) A 9.) B 10.) B 11.) B

Powered by Blogger.