Add sumDivisors and peterson implementation
parent
826b37d405
commit
7d9c4a6d3e
GPG Key ID:
2BE4AB7FDAD828A4
@ -1,47 +0,0 @@
|
||||
// For more information see https://aka.ms/fsharp-console-apps
|
||||
printfn "Hello from F#"
|
||||
|
||||
// printfn "%A" ((fun x -> x+1)3)
|
||||
|
||||
let ratio(x,y) =
|
||||
let z = x * y
|
||||
let w = 2 * (x + y)
|
||||
w / z
|
||||
|
||||
let ratio2(x : float, y : float) =
|
||||
let z = x * y
|
||||
let w = ((2 : float) * x) + ((2 : float) * y)
|
||||
w / z
|
||||
|
||||
printfn "%A" (ratio2(2.1,3.0))
|
||||
|
||||
let getType(x) = x.GetType().FullName
|
||||
|
||||
let rec Fib (n : int) =
|
||||
if (n = 0 || n = 1) then 1
|
||||
else Fib (n - 1) + Fib (n - 2)
|
||||
|
||||
let TrNum (n : int) = n*(n+1)/2
|
||||
|
||||
printfn "%A" (TrNum(10))
|
||||
|
||||
let rec ProdNum (n : int) =
|
||||
match n with
|
||||
| 1 -> 1
|
||||
| _ -> ProdNum(n-1)*n
|
||||
|
||||
let rec sumFirstFun f k =
|
||||
if k<=0 then 0 else f k + sumFirstFun f (k-1)
|
||||
|
||||
let rec fold g f k1 k2 z =
|
||||
if (k2 < k1) then z
|
||||
else g (fold g f (k1+1) k2 z) (f(k1))
|
||||
|
||||
let sum x y = x + y
|
||||
let double x = 2*x
|
||||
|
||||
printfn "%A" (fold sum double 10 100 0)
|
||||
|
||||
printfn "%A" (ProdNum(5))
|
||||
|
||||
printfn "%A" (Fib (5))
|
||||
@ -1,113 +0,0 @@
|
||||
let rec foldLeft g f k1 k2 z =
|
||||
if k1 >= k2 then g(z,f(k1))
|
||||
else g(foldLeft g f k1 (k2-1) z, f k2)
|
||||
|
||||
|
||||
let rec foldRight g f k1 k2 z =
|
||||
if k1 >= k2 then g(f(k1),z)
|
||||
else g(f k1, foldRight g f (k1+1) k2 z)
|
||||
|
||||
|
||||
|
||||
let list1 = [1; 2; 3]
|
||||
let list2 = [1,2,3]
|
||||
let list2' = [(1,2,3)]
|
||||
let list3 = (1,2,3)
|
||||
let list4 = []
|
||||
let list5 = 4::list1
|
||||
|
||||
let rec lngth lst =
|
||||
if lst = []
|
||||
then 0
|
||||
else 1 + (lngth (List.tail lst))
|
||||
|
||||
//printfn "%A" (lngth [1;3;4])
|
||||
|
||||
let rec invList l i =
|
||||
if l = [] then []
|
||||
else if ((List.length l) - i) = 0 then [List.head l]
|
||||
else
|
||||
l[List.length l - i] :: (invList l (i+1))
|
||||
|
||||
//printfn "%A" (invList [1;2;3;4] 1)
|
||||
|
||||
let reverseList l =
|
||||
let rec reverseL acc l =
|
||||
if l = [] then acc
|
||||
else
|
||||
reverseL ( (List.head l) :: acc) (List.tail l)
|
||||
reverseL [] l
|
||||
|
||||
//printfn "%A" (reverseList [1;2;3;4])
|
||||
|
||||
let rec sumList (l: int list) =
|
||||
if l = [] then 0
|
||||
else
|
||||
List.head l + sumList (List.tail l)
|
||||
|
||||
let rec maxL (l : int list) (max : int) =
|
||||
if l = [] then max
|
||||
else
|
||||
if (List.head l) > max then maxL (List.tail l) (List.head l)
|
||||
else maxL (List.tail l) max
|
||||
|
||||
let maxList l = if l= [] then failwith "Lista vuota" else maxL l (List.head l)
|
||||
|
||||
//printfn "%A" (sumList [1;2;3;4])
|
||||
|
||||
//printfn "%A" (maxList [1;2;3;4])
|
||||
|
||||
//printfn "%A" (maxList [])
|
||||
|
||||
let rec fib x =
|
||||
match x with
|
||||
| 1 -> 1
|
||||
| 2 -> 1
|
||||
| n -> fib (n-1) + fib (n-2)
|
||||
|
||||
let rec fib2 x =
|
||||
match x with
|
||||
| n when n < 1 -> failwith (sprintf "Error: %d is less than 1" x)
|
||||
| (1|2) -> 1
|
||||
| n -> fib (n-1) + fib (n-2)
|
||||
|
||||
let rec fn2 a =
|
||||
match a with
|
||||
| (x,y) when x > 0 && y > 0 -> x + y
|
||||
| (x,_) when x < 0 -> 0
|
||||
| _ -> failwith "This makes no sense"
|
||||
|
||||
let rec length2 l =
|
||||
match l with
|
||||
| [] -> 0
|
||||
| _ :: xs -> 1 + (length2 xs)
|
||||
|
||||
let rec nth i l =
|
||||
match (i,l) with
|
||||
| (_,[]) -> failwith "Errore: ricorsione termina in lista vuota"
|
||||
| (0, x :: _) -> x
|
||||
| (n, _ :: xs) when n > 0 -> nth (n-1) xs
|
||||
| _ -> failwith "Errore: indice negativo"
|
||||
|
||||
// printfn "%A" (nth 4 [1;2;3;4;5])
|
||||
|
||||
let rec EuclidsAlg n m =
|
||||
match (a,b) with
|
||||
| _ when (a <= 0 || b <= 0) -> failwith "Errore: almeno un numero non positivo"
|
||||
| _ when (a = b) -> a
|
||||
| _ when (a > b) -> EuclidsAlg (a-b) b
|
||||
| _ -> EuclidsAlg a (b-a)
|
||||
|
||||
let rec unzip l =
|
||||
match l with
|
||||
| [] -> ([],[])
|
||||
| (a,b) :: xs -> (a :: (fst (unzip xs)), b :: (snd (unzip xs)));;
|
||||
|
||||
// printfn "%A" (EuclidsAlg 48 12)
|
||||
|
||||
let rec unzip' l =
|
||||
match l with
|
||||
| [] -> ([],[])
|
||||
| (a,b) :: xs ->
|
||||
let (aa,bb) = unzip xs
|
||||
(a :: aa, b :: bb)
|
||||
@ -0,0 +1,87 @@
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
// This program illustrates the use of Peterson's algorithm to synchronize
|
||||
// multiple threads.Two new threads are created and alternate writing to the
|
||||
// standard output.
|
||||
//
|
||||
// The key difference between Peterson's algorithm and strict alternation is
|
||||
// the inclusion of flags indicating whether a thread is ready to enter the
|
||||
// critical section.
|
||||
|
||||
// This function is taken from `~/.local/src/dwm/util.c`.
|
||||
//
|
||||
// Print the error message and `perror` if the message ends in `':'`. Assumes
|
||||
// `fmt` is not `NULL`.
|
||||
void die(const char* fmt, ...) {
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
vfprintf(stderr, fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
// Following Unix convention (see `man perror`), first check if the string is
|
||||
// not empty.
|
||||
if(fmt[0] && fmt[strlen(fmt) - 1] == ':') {
|
||||
fputc(' ', stderr);
|
||||
perror(NULL);
|
||||
} else {
|
||||
fputc('\n', stderr);
|
||||
}
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
// The `turn` variable indicates which thread should enter the critical
|
||||
// section. Unlike strict alternation, the `turn` variable is set _before_
|
||||
// entering the critical section.
|
||||
//
|
||||
// Note that globally-scoped variables are initialized to zero.
|
||||
int turn;
|
||||
int flag[2];
|
||||
|
||||
void* f0(void* arg) {
|
||||
while(1) {
|
||||
// Signal that this thread wants to enter the critical section.
|
||||
flag[0] = 1;
|
||||
// Signal to the other thread that it is their turn.
|
||||
turn = 1;
|
||||
while(flag[1] && turn == 1);
|
||||
puts("hello");
|
||||
flag[0] = 0;
|
||||
sleep(1);
|
||||
}
|
||||
}
|
||||
|
||||
void* f1(void* arg) {
|
||||
while(1) {
|
||||
flag[1] = 1;
|
||||
turn = 0;
|
||||
while(flag[0] && turn == 0);
|
||||
puts("world");
|
||||
flag[1] = 0;
|
||||
sleep(1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
// A POSIX thread has two main components: an object of type `pthread_t`
|
||||
// which represents the thread and a function pointer of type
|
||||
// `void* (*)(void*)` which will be the entry point of the thread.
|
||||
pthread_t t0, t1;
|
||||
|
||||
// Creates new threads. The second argument is a pointer to a
|
||||
// `pthread_attr_t`, if `NULL` the thread is created with default attributes.
|
||||
// The last argument is the argument that is given to the thread's entry
|
||||
// point function, unused in this example.
|
||||
if(pthread_create(&t0, NULL, f0, NULL)) die("unable to create thread");
|
||||
if(pthread_create(&t1, NULL, f1, NULL)) die("unable to create thread");
|
||||
|
||||
// Yes, I could have just created one thread.
|
||||
while(1);
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
open System
|
||||
|
||||
let factorsWithMolteplicity n =
|
||||
let rec loop c p =
|
||||
if c < (p * p) then [c]
|
||||
elif c % p = 0 then p :: (loop (c/p) p)
|
||||
else loop c (p + 1)
|
||||
loop n 2
|
||||
|> List.countBy id
|
||||
|
||||
let isPerfect n =
|
||||
let sumDiv k =
|
||||
k
|
||||
|> factorsWithMolteplicity
|
||||
|> List.map (fun (p,m) -> ((pown p (m+1))-1)/(p-1))
|
||||
|> List.fold (*) 1
|
||||
sumDiv n = 2*n
|
||||
|
||||
// brute-force approach
|
||||
let divisors n =
|
||||
[1..n/2]
|
||||
|> Seq.filter (fun f -> n % f = 0)
|
||||
let sumProperDivisors n =
|
||||
n
|
||||
|> divisors
|
||||
|> Seq.sum
|
||||
|
||||
// perfect
|
||||
let isPerfect2 n = (sumProperDivisors n = n)
|
||||
|
||||
let timer = new System.Diagnostics.Stopwatch()
|
||||
timer.Start()
|
||||
printfn "%A" (isPerfect 8128)
|
||||
timer.Stop()
|
||||
printfn "%f" timer.Elapsed.TotalMilliseconds
|
||||
printfn "Elapsed Time: %i" timer.ElapsedMilliseconds
|
||||
|
||||
let timer2 = new System.Diagnostics.Stopwatch()
|
||||
timer2.Start()
|
||||
printfn "%A" (isPerfect2 8128)
|
||||
timer2.Stop()
|
||||
printfn "%f" timer2.Elapsed.TotalMilliseconds
|
||||
printfn "Elapsed Time: %i" timer2.ElapsedMilliseconds
|
||||
@ -0,0 +1,24 @@
|
||||
N=1e7;
|
||||
|
||||
for n=2:N
|
||||
% A contains the unique prime factors of n; M their multiplicities
|
||||
[A,M]=factor(n);
|
||||
l=length(A);
|
||||
s=1;
|
||||
for i=1:l
|
||||
% formula for the sum of divisors of p^k
|
||||
c(i)=((A(i)^(M(i)+1))-1)/(A(i)-1);
|
||||
s*=c(i);
|
||||
end
|
||||
if 2*n==s
|
||||
printf("%d is Perfect!\n",n)
|
||||
m=n;
|
||||
k=0;
|
||||
while mod(m,2)==0
|
||||
m=m/2;
|
||||
k++;
|
||||
end
|
||||
k++;
|
||||
printf("The corresponding Mersenne prime is %d\n",((2^k)-1))
|
||||
end
|
||||
end
|
||||
Loading…
Reference in New Issue