Problem 3: a note
Find the largest prime factor of a composite number.
The problem of integer factorization is one of the most important in the number theory. Last time I implemented a classical algorithm with complexity. The author of the Project Euler website suggests a small improvement  iterating over only odd numbers, but I consider this as too tiny thing to do.
As regards the problem of factorization, I'd rather look in special literature, what are the known approaches (and I'll do that later, let's switch to the next one).
Problem 2 ver. 2, 3, 4: logarithmic complexity
Find the sum of all the evenvalued terms in the Fibonacci sequence which do not exceed four million
The last time we had the straightforward O(n) solution: building a sequence, filtering out even values and adding them. We can improve a bit, noticing that actually, every third member of the Fibonacci sequence is even. We don't check then for evennes, but just jump over three components each time. This version 2 (I don't publish it here) should be several times faster, but still is O(n) in performance.
We can also express a member of the Fibonacci sequence via the third and sixth members from behind: and compute those values as the values of a new sequence: . This version 3 is essentially the same as the previous one and again, I don't publish it here.
The drastic improvement is obtained using the expression (I've added it and a proof to the wikipedia article, but they immediately reverted my changes as "unsourced"  this is pathetic). Now the sum is obtained just computing one Fibonacci member, and this can be done with O(log n).
Indeed, we can compute a Fibonacci member exponentiating the appropriate matrix, and this exponentiation, just like usual one, can be done with O(log n). I prefer this solution over using the golden ratio exponentiation formula (again logarithmic complexity), because only integeroperations are involved. So, this is the version 4 of the solution.

(define (fibonaccimemberlogarithmic n) (matrix2da12 (^2d fibonaccimatrix n)))

(define (fibonaccisumeven n) (/ ( (fibonaccimemberlogarithmic (+ n 2)) 1) 2))
I quickly outlined a class for 2D matrices and operations with it:

(definerecordtype matrix2d (fields a11 a12 a21 a22))

(define identitymatrix2d (makematrix2d 1 0 0 1))

(define fibonaccimatrix (makematrix2d 1 1 1 0))

(define (*2d A B) (let ([a11 (matrix2da11 A)]

[a12 (matrix2da12 A)]

[a21 (matrix2da21 A)]

[a22 (matrix2da22 A)]

[b11 (matrix2da11 B)]

[b12 (matrix2da12 B)]

[b21 (matrix2da21 B)]

[b22 (matrix2da22 B)])

(makematrix2d (+ (* a11 b11) (* a12 b21)) (+ (* a11 b12) (* a12 b22))

(+ (* a21 b11) (* a22 b21)) (+ (* a21 b12) (* a22 b22)))))

(define (^2dlinear A n) (applyntimes identitymatrix2d n (lambda (x) (*2d x A))))

(define (^2dlogarithmic A n) (if (= n 0) identitymatrix2d

(if (odd? n) (*2d A (^2dlogarithmic A ( n 1)))

(let ([B (^2dlogarithmic A (div n 2))]) (*2d B B)))))

(define ^2d ^2dlogarithmic)
The solution is O(1) in memory and O(log n) in performance  of course, where n denotes the index of a number in the Fibonacci sequence. And we have been questioned about the cutset, where members of a sequence are less than certain number. Then an additional function (closestfibonacciindex) comes in handy (see the wiki for explanation):

(define goldenratio (/ (+ 1 (sqrt 5)) 2))

(define (closestfibonacciindex f) (round (log (* f (sqrt 5)) goldenratio)))

(define (solution2optimized3 n) (fibonaccisumeven (closestfibonacciindex n)))
The final touch is asking ourselves about complexity of the (log) function. Well, it can be computed fast enough not to spoil complexity of the algo's main part.
Problem 1 ver. 3: optimization
Find the sum of all the multiples of 3 or 5 below 1000.
Let us generalize again to a finite set of factors.
There is a formula for the power of finite sets
which can be generalized to a finite number of finite sets
or in a somewhat less understandable, but concise notation
Here is a measure (i.e. it commutes with the union sign) and can be replaced with  power of a set sign or, if we are in the natural numbers space, with the sum of elements sign, as in our case. is not a multiindex, but a subset of the natural numbers cut from to .
Now by we denote the set of all the multiples of factors , less than certain number N, where i varies from 1 to n (each is respectively the set of multiples of a factor ). We use the abovementioned formula to compute the measure of the union via measures of all and measures of all finite intersections of them.
Suppose, we have a number , prime or not, and the set of all it's multiples (they include only numbers less than N). Power of this set is of course (div operation) and the sum of its members can be calculated by the wellknown formula for the sum of an arithmetic progression.
As regards all the intersections, it is understandable that we ought to calculate the least common multiple (LCM) of taken factors, and the setintersection of their multiples will be just a set of its multiples. However, the current version of the solution assumes that we take primes as factors, then the LCM of them is just their product. When I calculate proper LCM in Problem 5 (up to now there is a bruteforce version), I will switch the temp version to it.
Let's see the solution. New util functions:

(define (mullist list) (foldleft * 1 list))

(define (^ base power) (expt base power))

(define (sumarithmeticprogression first step n) (/ (* n (+ (* 2 first) (* step ( n 1)))) 2))
The function that calculates subsets of a set:

(define (subsets set)

(define (recursion set rest) (if (null? set) (list rest)

(let ([head (car set)] [tail (cdr set)])

(append (recursion tail rest) (recursion tail (cons head rest))))))

(recursion set '()))
Important thing about this function is that it returns the empty set as the first element and the full set as the last element of a result list, all other subsets are in between. The number of subsets of a finite subset is just , so the complexity is  it would be better visible with an imperativeiterative version of this function (I'm not posting it here). As regards memory, the function generates all the subsets as lists which in whole contain elements (strange, this neat formula isn't on Wikipedia yet, I should add it there), that is the memory load is . This is a notsogood idea to load everything into memory, as we can rewrite this function (and the function that is down here in the post) iteratively with O(n) memory complexity  taking advantage of combinadics, but for now I am satisfied enough with this version.
Using the formula above the solution now as simple as

(define (summultipleslessthan n divisors)

(define (sumofone factor) (sumarithmeticprogression factor factor (div n factor)))

(define (lcmtemp factors) (if (null? factors) 0 (mullist factors)))

(define (measure subset) (* (^ ( 1) (+ (length subset) 1)) (sumofone (lcmtemp subset))))

(sumlist (map measure (cdr (subsets divisors)))))
With that (cdr) I cut off the empty subset, whose measure is zero (otherwise the (sumofone) function has to be a bit more complex).
Let's be careful with notation: n here is actually not the same n, as in the (subsets) function, but the number up there, the maximum of our multiplessets. The performance complexity depends on k and N, but we are interested only in complexity, depending on N. Let's assume that k is small comparing to N, which should be the usual case. Then the complexity is roughly speaking O(1), doesn't depend on N, as we wanted (I remind that in the previous version we had O(N) complexity).
The final touches are the regression tests:

(assert (=

(sumlist (multipleslessthanbruteforce 10 '(3 5)))

(summultipleslessthan 10 '(3 5))))

(assert (=

(sumlist (multipleslessthanbruteforce 1000 '(3 5)))

(summultipleslessthan 1000 '(3 5))))

(assert (=

(sumlist (multipleslessthanbruteforce 10000 '(3 5 7 19)))

(summultipleslessthan 10000 '(3 5 7 19))))

;(assert (=

; (sumlist (multipleslessthanbruteforce 1000 '(3 5 15)))

; (summultipleslessthan 1000 '(3 5 15))))
The last commented one breaks, of course, as 15 is not prime  the LCM algo should be updated still.
Basic laptop maintenance
Some months ago my notebook began to overheat. When the CPU is loaded enough, its temperature grows over 95 degrees Celsius, and a guard mechanism throttles down its frequency to 40 % and waits until it cools down. Within a few minutes the system is badly responsive.
I bought a cooling platform for it, but with time it couldn't restrain the heat. A problem became worse and worse, but the warranty for the laptop was void already. So, I took a screwdriver and solved it:
A dense layer of dust covered the radiator and prevented air flow. Now under 100 % load my CPU is cool enough. I mean, for a Turion  80 degrees Celsius for the general sensor, 85 for the first core, and 9193 for the second one (sitting on a table, without a cooling platform). Strange gradient, but anyway, a system doesn't freeze now.
Learned a bit about PLTScheme
I've looked through the Quick: An Introduction to PLT Scheme with Pictures document. And what I've learned is:
 There is a library (#lang slideshow) embedded into PLTScheme, which provides some easytouse graphic primitives and a GUI library (scheme/gui/base). The first can be used for drawing on GUI's canvases.
 There is an OOP library (scheme/class). I should look what's the backbone later.
 PLT has the distribution system for libraries. The first eval of (require (planet something)) downloads from the PLaneT server and caches 'something' locally.
The last is quite nice, I should run through that server and look which libraries are actually implemented.
How to pivot (rotate a desktop from landscape to portrait)
Monitors become wider and wider due to the entertainment industry, but changing proportion in fact decreases a number of pixels from top to bottom of a screen. If you look at some program code now, you see just some lines clustered along the left boundary of a screen and lots of free space.
A standard coder should not appreciate that, unless he is me and likes spaghetti code style (by this I mean lines 200 symbols wide). However, this is applicable only for code in the functional paradigm. In the imperative style I don't do this. And anyway, there are usually code style conventions limiting that for a project.
I've seen some people using two source code windows filled with different source files. This could be nice, especially for diffs. However, I think, a coder should appreciate increasing number of lines vertically. The ultimate solution is to buy a monitor with the pivot function  switching between landscape and portrait onthefly. Of course, this requires support from drivers/OS. And nvidia, radeon drivers provide that.
Switching under Windows is easy, for Linux it required some investigations. You enable it first in /etc/X11/xorg.conf (Section "Screen"):
Option "RandRRotation" "true"
This is for nvidia card, but I guess, radeon drivers should provide the same. Then under KDE you run a command:
xrandr o left
to switch to the portrait mode or "o normal" for switching back.
I also tried krandrtray application, but it didn't work for me. By the way, don't logout from KDE during the portrait mode. I filed a bug for the KDE team.
Installed LaTeX plugin for WordPress
I tried wpmathpub plugin, but it didn't work for me. Now thanks to Craig Rose I have a better plugin for math notation. It uses an external service (usually WordPress server) for turning LaTeXnotation into pics, and thus capable of much more than wpmathpub plugin (that uses the PhpMathPublisher library and implements just a small subset of TeXformulae).
Now with math notation possible to post here I will think up and publish some optimizations for Project Euler problems.
Problem 7 ver. 1 and 2: bruteforce and optimization
Find the 10001st prime.
The problem of finding primes is the most famous computational task in the number theory.
At first, let's update the (generatelistiteratively) function. It now includes i  the parameter, which denotes number of eligible elements up to this moment. We use it in the stopping condition.

(define (generatelistiteratively seed filter map step stop)

(define (iterate current i) (if (stop current i) '()

(let* ([ok (filter current)] [next (if ok (+ i 1) i)] [rest (iterate (step current) next)])

(if ok (cons (map current) rest) rest))))

(iterate seed 0))
Dependant functions are rewritten also. I refactored the factorization functions and added primality tests (usual straightforward ones):

(define (minimalfactorbruteforce n)

(define (iterate n x) (if (> x n) n (if (divides? n x) x (iterate n (+ x 1)))))

(iterate n 2))

(define (minimalfactorsqrtcomplexity n)

(define (iterate n x) (if (> x (sqrt n)) n (if (divides? n x) x (iterate n (+ x 1)))))

(iterate n 2))

(define (factorize n minimalfactor) (let ([p (minimalfactor n)]) (if (= p n) (list p) (cons p (factorize (/ n p) minimalfactor)))))

(define (prime?bruteforce n) (= (minimalfactorbruteforce n) n))

(define (prime?sqrtcomplexity n) (= (minimalfactorsqrtcomplexity n) n))

(define (primeslist n prime?) (generatelistiteratively 2 prime? (lambda (x) x) (lambda (x) (+ x 1)) (lambda (x i) (= i n))))
Now, having an extra function that returns the last element in a list, we can easily solve the 7th problem:

(define (last list) (if (null? (cdr list)) (car list) (last (cdr list))))

(define (solution7bruteforce n) (last (primeslist n prime?bruteforce)))

(define (solution7optimized1 n) (last (primeslist n prime?sqrtcomplexity)))
The complexity in memory is O(n), as we store n primes. It could be O(1), of course, but I prefer this way for now. The performance complexity of the algorithm is hard to determine. Probably, I need to overlook some literature for that.
Problem 6 ver. 1: bruteforce
What is the difference between the sum of the squares and the square of the sums?
No problems with bruteforce here.

(define (square n) (* n n))

(define (solution6bruteforce n) (let ([ns (numbers 1 n)]) ( (square (sumlist ns)) (sumlist (map square ns)))))
The number of operations (additions and multiplications) here is 3*n + 2. The complexity is O(n), and the algo is O(n) in memory as well (of course, can be done with O(1) in memory).