Faz qualquer coisa...

Este é um blog de geral de matemática, física, electrónica, áudio, LISP, Arduino, impressão 3D, etc, ... Já tem uns anitos :)

As entrada antigas estão arquivadas de uma forma não linear.

Happy hacking!

RSS

[Valid RSS]


Raytracing
... with povray

2021/03/03-10:25:07

Some examples in povray and further reading.

global_settings{ 
   ambient_light rgb<1,1,1>
   
   photons{ count 100000
     media 10
     autostop 0
     jitter .4
   }
}
light_source {<0,10,5>,1}

camera{location <30,30,5> 
  right x*image_width/image_height look_at 0}


cylinder{<0,0,0>,<0,10,0>,2
  pigment{ color rgbf <1,1,1,1> } 
  finish{
    reflection .1
    ior 1.2
    phong 0}
 photons { target reflection on } 
  photons {
    target
    refraction on
    reflection on
    collect off
  }
}
 
plane{y,0
  pigment{
    color rgb <.3,.3,.3>
     }
  finish{ 
    diffuse .7
    reflection 0}
 }

global_settings
 { 
   ambient_light rgb<1,1,1>
   photons{ count 100000
     media 10
     autostop 0
     jitter .4
   }
 }

light_source {<0,7,5>,.5
}

camera{location <30,30,5> 
  right x*image_width/image_height look_at 0}

sphere{<-1,3,1>,5
  pigment{ color rgbf <1,1,1,1> } 
  finish{
    reflection .1
    ior 1.2
    phong 0}
 photons { target reflection on } 
  photons {
    target
    refraction on
    reflection on
    collect off
  }
}

plane{y,-2.5
  pigment{
    color rgb <.3,.3,.3>
     }
  finish{ 
    diffuse .7
    reflection 0}
 }

Etiquetas/Tags: povray, raytracing


So the opposite of addiction is not sobriety. It is human connection.
... experiências em ratos e outras coisas

2020/11/13-16:52:48

http://www.huffingtonpost.com/johann-hari/the-real-cause-of-addicti_b_6506936.html

Muito giro, mas há um catch... o que o estudo mostra é que os ratinhos substituem a droga por contactos sociais (em vez de consumirem a droga até à morte) não deixam, no entanto, de a continuar a tomar.

So the opposite of addiction is not sobriety. It is human connection.

A experiência mostra, de facto, que os ratinhos consomem droga em simultâneo com a interacção social e que o consumo de drogas neste caso não leva à morte. Não serve como argumento para erradicação do consumo de drogas.

O que o consumo de tabaco mostra e confirma, outra experiência, é que se começa a fumar por causa da interacção social.

Etiquetas/Tags: drugs, confusões, ratos


Principle of least constraint
Equações de movimento e resolução numérica do movimento de um ponto material sobre uma superfície

2020/11/08-22:23:24

Uma das imagens que sempre me cativou, a representação do movimento de um ponto material sobre uma superfície apenas sujeito ao seu próprio peso. Essa mesma figura é recorrente em muitos livros de física em particular em livros de gravitação, e em livros de divulgação, dita, científica. No entanto, apesar de todo o rigor inerente a qualquer um dos dois tipos de publicação, as equações usadas para construir essas figuras nunca aparecem.

Certamente por aquelas serem, é uma hipótese, uma representação de artista que tenta capturar a ideia rigorosa que se quer ilustrar.

As duas figuras seguintes mostram o movimento de um ponto material sobre um parabolóide, a primeira sem atrito e a segunda com atrito, com as mesmas condições iniciais [0 1 1 0] (ver código em Octave mais à frente).

 sem atrito (k=0)
sem atrito (k=0)
com atrito (k=.05)
com atrito (k=.05)

Vejamos então como construir as equações. Uma das formas de as obter é usando o Principle of least constraint, que pode se visto como um certo tipo de método dos mínimos quadrados. Tem o seguinte enunciado para um único ponto material: a aceleração de um ponto material minimiza a quantidade latex2png equation para quaisquer restrições cinemáticas

latex2png equation

onde latex2png equation, latex2png equation, latex2png equation e latex2png equation, são respectivamente a massa e as componentes da força a que está sujeito o ponto.

Como queremos obter a trajectória de um ponto material que se move sobre um superfície apenas sujeito ao seu próprio peso, vem que, latex2png equation e que latex2png equation e latex2png equation onde latex2png equation é a aceleração da gravidade (uma constante positiva).

É condição necessária para a existência de um mínimo que

latex2png equation

e obtém-se

latex2png equation onde latex2png equation

Esta última equação obtém-se de

latex2png equation usando as equações de latex2png equation e latex2png equation.

O passo seguinte consiste em implementar a resolução numérica das equações (1) e (2) em Octave. Assim, o sistema de e.d.o's é implementado pela função em Octave f.m, para o caso de latex2png equation

function xdot=f(x,t)
  dfdx=2*x(1);
  dfdy=2*x(3);
  d2fdx2=2;
  d2fdy2=2;
  d2fdxdy=0;
  g=1;
  k=0.05;
  xdot = zeros (4,1);
  d2z=(x(2)^2*d2fdx2+x(4)^2*d2fdy2+2*x(2)*x(4)*d2fdxdy-g*(dfdx^2+dfdy^2))/(1+dfdx^2+dfdy^2);
  xdot(1)=x(2);
  xdot(2)=-k*x(2)-dfdx*(g+d2z);
  xdot(3)=x(4);
  xdot(4)=-k*x(4)-dfdy*(g+d2z);
endfunction;

onde se inclui um termo de dissipação, proporcional ás velocidades, com coeficiente de atrito k. Os comandos para gerar os gráficos anteriores são
#1

clear all
clf

l=1;
xl=linspace(-l,l,20);
yl=linspace(-l,l,20);
[x y]=meshgrid(xl,yl);


t = linspace (0, 100, 1000);
xini=[0 1 1 0]
z = lsode ("f", xini, t);

hold on

mesh(x,y,x.^2+y.^2)
plot3(z(:,1), z(:,3),z(:,1).^2+ z(:,3).^2,'b')

As duas imagens seguintes mostram outras versões das mesmas figuras assim como os retratos de fase para cada uma da coordenadas

sem atrito (k=0)
sem atrito (k=0)
com atrito (k=.05)
com atrito (k=.05)

Etiquetas/Tags: matemática, física, Gauss, Principle of least constraint


Vertex Nano 3d printer
... config files and whatnot

2020/10/06-11:58:01

Just got a Velman Vertex Nano 3D printer. Had to hack a glass to replace the original stuff that was over the bed. Works nicely now.

Here's the configuration gdode files. Have fun!

M502 ;Revert to the default "factory settings."
M500 ;Store parameters in EEPROM
M117 HOMING...
G28  ;Auto home
M117 POSITIONING NOZZLE
G1 X40 Y40 Z2 F500 ;Position Nozzle
G4 S1 ;Wait a second
M117 MOVE Z TO TOUCH BED
M117 POSITIONING NOZZLE
G1 X0 Y80 F500 ;Position Nozzle
G4 S1 ;Wait a second
M117 APPLY HOME OFFSETS

1. Save these files onto a SD-CARD

Save these 2 files onto an SD-CARD you can use for the Vertex Nano (step1.gcode step2.gcode)

2. Run step1.gcode

Insert the SD-CARD into the Vertex Nano and power it up. Navigate to the PRINT FROM SD-CARD menu and choose the step1.gcode file.

The printer will go through some steps and come to a complete stop with the following message on the screen: MOVE Z TO TOUCH BED

3. Move axis (Z touching bed)

Navigate to the MOVE AXIS menu and choose MOVE 0.1mm.

Then choose Move Z and move the HOTEND downwards by turning the knob, until it just touches the bed. You should still be able to slide a piece of normal paper between the BED and the NOZZLE.

If you have completed this part, go back to the main menu.

4. Run step2.gcode

Navigate to the PRINT FROM SD-CARD menu, and choose the setp2.gcode file.

The printer will go through some steps and come to a complete stop with the following message on the screen: APPLY HOME OFFSETS

5. Set home offsets

Lastly, simply click SET HOME OFFSETS in the control menu to finalize the calibration. 'Offsets applied' should now appear on the information screen. If so, continue to the next chapter!

Etiquetas/Tags: vertex nano, 3d, 3d printer


Cubos e mais cubos
... em OpenSCAD

2020/10/02-22:05:34

Há muito tempo que não fazia uma brincadeira destas: fazer uma animação em OpenSCAD.

A maneira mais simples é gerar uns quantos PNG, com a opção de animação do OpenSCAD, e depois usar o imagemagick com o comando

convert -delay 10 *.png anim.gif
para gerar um GIF e depois o ffmpeg
ffmpeg -i anim.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" video.mp4
para gerar o MP4.

Mas há questão da resolução do output do OpenSCAD porque queria gerar um GIF com 1920x1080. Claro que o Openscad pode ser usado na linha de comando e com uma função em ELISP

(defun scad-anim()
  (interactive)
  (setq i 0.0)
  (while (< i 100.0)
    (shell-command (concat
                    "openscad-nightly "
                    (buffer-name) " --imgsize=680,680 --export-format png -o 00"
                    (if (eql (/ (floor i) 10) 0)
                        (concat "0" (number-to-string (floor i)))
                      (number-to-string (floor i)))
                    ".png -D t="
                    (number-to-string (* .01 i))))
    (setq i (+ i 1))))
gera-se as 100 imagens para a animação1.

O código em Openscad é o seguinte e está sob uma licença GPLv3

m=799;
v=[for (i=[0:m])rands(0,1,3,i)];
t=1;

module rotobj(t=0){
    lc=5;
    rotate([t*360,t*360,t*360])
    color("white")    
    cube(lc*[1,1,1],center=true);}


translate([(-300+t*500),0,-600])
rotate(t*v[1]*360) 
rotate([0,60,90])
scale(2*[1,1,1])
color("red")
import("Voyager_17.stl");

rotate([t*20,-t*5,t*10]){
    lcube=10000;
    translate([0,0,-1000])
    color([0/255,0/255,0/255])
    cube([lcube,lcube,1],center=true);
    
    ls=16;
    for(i=[0:m]){
        translate(ls*([ls*(.5-v[i][0]),ls*(.5-v[i][1]),ls*(.5-v[i][2])])){
            rotate(v[i]*360) 
            rotobj(t);}}  
}

$vpt=[0,0,0];
$vpr=[0,0,0];
$vpd=300;

Happy hacking!

P.S.

A Voyager que aparece em background é daqui: https://nasa3d.arc.nasa.gov/detail/jpl-vtad-voyager

1.

Sim, estou a usar modo scad para o Emacs: https://nexp.pt/scad-mode.html

Etiquetas/Tags: OpenSCAD, Emacs, animation


OpenSCAD mode for emacs
... my hack.

2020/10/02-22:04:20

;;scad.el --- Major mode for editing SCAD files
;; Original author: Len Trigg <lenbok@gmail.com>
;; Maintainer: This hack is maintained by tca  <tca@diale.org>
;; Created:    20141107
;; Modified:   20141107
;; Keywords:   OpenSCAD, emacs, mode
;; URL:        http://diale.org/scad.el.html
;; Version:    0.1
;; Comments: Added a bunch of skeletons and keymaps.
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2 of the License, or
;; (at your option) any later version.
;; 
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; 
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;
;;; Commentary:
;;
;; This is a major-mode to implement the SCAD constructs and
;; font-locking for openscad
;;; Code:

;;;###autoload

(add-to-list 'auto-mode-alist '("\\.scad$" . scad-mode))

(defcustom scad-command
  '"~/Downloads/openscad-2014.03/local_inst/bin/openscad"
  "Path to openscad executable"
  :type 'string)

(defcustom scad-keywords
  '("return" "true" "false")
  "SCAD keywords."
  :type 'list
  :group 'scad-font-lock)

(defcustom scad-functions
  '("cos" "acos" "sin" "asin" "tan" "atan" "atan2"  
    "abs" "sign" "rands" "min" "max" 
    "round" "ceil" "floor" 
    "pow" "sqrt" "exp" "log" "ln"
    "str" 
    "lookup" "version" "version_num" "len" "search"
    "dxf_dim" "dxf_cross")
    "SCAD functions."
  :type 'list
  :group 'scad-font-lock)

(defcustom scad-modules
  '("child" "children" "echo" "assign" "for" "intersection_for" "if" 
    "else" "cube" "sphere" "cylinder" "polyhedron" "square" "circle" 
    "polygon" "scale" "rotate" "translate" "mirror" "multmatrix" "union"
    "difference" "intersection" "render" "color" "surface" 
    "dxf_linear_extrude" "linear_extrude" "dxf_rotate_extrude" 
    "rotate_extrude" "import_stl" 
    "import_off" "import_dxf" "import" "group" 
    "projection""minkowski" "glide" "subdiv" "hull" "resize")
    "SCAD modules."
  :type 'list
  :group 'scad-font-lock)

(defcustom scad-operators
  '("+" "-" "*" "/" "%" 
    "&&" "||" "!" 
    "<" "<=" "==" "!=" ">" ">="
    "?" ":" "=")
  "SCAD operators."
  :type 'list
  :group 'scad-font-lock)

;; "C-c letter"  are reserved for users

(defvar scad-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "\t" 'scad-indent-line)
    (define-key map (kbd "C-c C-v") 'scad-open-current-buffer)
    (define-key map (kbd "C-c C-c") 'scad-output-stl)

    ;; s for solid
    (define-key map (kbd "C-c C-s c") 'scad-cylinder)
    (define-key map (kbd "C-c C-s u") 'scad-cube)
    (define-key map (kbd "C-c C-s y") 'scad-cylinder)
    (define-key map (kbd "C-c C-s p") 'scad-polyhedron)

    ;; b for Boolean
    (define-key map (kbd "C-c C-b u") 'scad-union)
    (define-key map (kbd "C-c C-b d") 'scad-difference)
    (define-key map (kbd "C-c C-b i") 'scad-intersection)

    ;; t for transformations
    (define-key map (kbd "C-c C-t t") 'scad-translate)
    (define-key map (kbd "C-c C-t r") 'scad-rotate)
    (define-key map (kbd "C-c C-t s") 'scad-scale)
    (define-key map (kbd "C-c C-t z") 'scad-resize)
    (define-key map (kbd "C-c C-t m") 'scad-mirror)
    (define-key map (kbd "C-c C-t x") 'scad-multmatrix)
    (define-key map (kbd "C-c C-t c") 'scad-color)
    (define-key map (kbd "C-c C-t h") 'scad-hull)
    (define-key map (kbd "C-c C-t k") 'scad-minkowski)

    ;; s for syntax
    (define-key map (kbd "C-c C-s m") 'scad-module)
    (define-key map (kbd "C-c C-s f") 'scad-function)
    (define-key map (kbd "C-c C-s i") 'scad-include)
    (define-key map (kbd "C-c C-s u") 'scad-use)

    ;; m for math
    ;; Is this really needed;)

    ;; f for functions
    (define-key map (kbd "C-c C-f l") 'scad-lookup)
    (define-key map (kbd "C-c C-f r") 'scad-str)
    (define-key map (kbd "C-c C-f c") 'scad-chr)
    (define-key map (kbd "C-c C-f s") 'scad-search)
    (define-key map (kbd "C-c C-f n") 'scad-version-num)
    (define-key map (kbd "C-c C-f n") 'scad-norm )
    (define-key map (kbd "C-c C-f c") 'scad-cross)
    (define-key map (kbd "C-c C-f m") 'scad-parent-module)

    ;; o for others
    (define-key map (kbd "C-c C-o r") 'scad-render)
    (define-key map (kbd "C-c C-o f") 'scad-for)
    (define-key map (kbd "C-c C-o t") 'scad-intersection-for)
    (define-key map (kbd "C-c C-o i") 'scad-if)
    (define-key map (kbd "C-c C-o a") 'scad-assign)
    (define-key map (kbd "C-c C-o m") 'scad-import)
    (define-key map (kbd "C-c C-o x") 'scad-linear-extrude)
    (define-key map (kbd "C-c C-o o") 'scad-rotate-extrude)
    (define-key map (kbd "C-c C-o s") 'scad-surface)
    (define-key map (kbd "C-c C-o p") 'scad-projection)
    (define-key map (kbd "C-c C-o c") 'scad-children)

    ;; p for on the plane
    (define-key map (kbd "C-c C-p c") 'scad-circle)
    (define-key map (kbd "C-c C-p s") 'scad-square)
    (define-key map (kbd "C-c C-p p") 'scad-polygon)

    (define-key map [return] 'newline-and-indent)
    map)
  "Keymap for `scad-mode'.")

(defvar scad-mode-syntax-table
  (let ((st (make-syntax-table)))
    ;; support comment style: “// ...” 
    ;; support comment style: “/* ... */” 
    (modify-syntax-entry ?\/ ". 124b" st)
    (modify-syntax-entry ?\n "> b" st)
    (modify-syntax-entry ?* ". 23" st)

    ;; Extra punctuation
    (modify-syntax-entry ?+  "." st)
    (modify-syntax-entry ?-  "." st)
    (modify-syntax-entry ?%  "." st)
    (modify-syntax-entry ?<  "." st)
    (modify-syntax-entry ?>  "." st)
    (modify-syntax-entry ?&  "." st)
    (modify-syntax-entry ?:  "." st)
    (modify-syntax-entry ?|  "." st)
    (modify-syntax-entry ?=  "." st)
    (modify-syntax-entry ?\;  "." st)

    ;; _ allowed in word (alternatively "_" as symbol constituent?)
    (modify-syntax-entry ?_  "w" st) st)
  "Syntax table for `scad-mode'.")

(defvar scad-keywords-regexp (regexp-opt scad-keywords 'words))
(defvar scad-modules-regexp (regexp-opt scad-modules 'words))
(defvar scad-functions-regexp (regexp-opt scad-functions 'words))
(defvar scad-operators-regexp (regexp-opt scad-operators))

(defvar scad-font-lock-keywords
  `(
    ("\\(module\\|function\\)[ \t]+\\(\\sw+\\)" (1 'font-lock-keyword-face nil) (2 'font-lock-function-name-face nil t))
    ("\\(use\\|include\\)[ \t]*<\\([^>]+\\)>" (1 'font-lock-preprocessor-face nil) (2 'font-lock-type-face nil t))
    ("<\\(\\sw+\\)>" (1 'font-lock-builtin-face nil))
    ("$\\(\\sw+\\)" (1 'font-lock-builtin-face nil))
    (,scad-keywords-regexp . font-lock-keyword-face)
    (,scad-modules-regexp .  font-lock-builtin-face)
    (,scad-functions-regexp .  font-lock-function-name-face)
    ;(,scad-operators-regexp .  font-lock-operator-face) ;; This actually looks pretty ugly
    ;("\\(\\<\\S +\\>\\)\\s *(" 1 font-lock-function-name-face t) ;; Seems to override other stuff (e.g. in comments and builtins)
    )
  "Keyword highlighting specification for `scad-mode'.")

;(defvar scad-imenu-generic-expression ...)
;(defvar scad-outline-regexp ...)

;;;###autoload
(define-derived-mode scad-mode fundamental-mode "SCAD"
  "A major mode for editing SCAD files."
  :syntax-table scad-mode-syntax-table
  (set (make-local-variable 'font-lock-defaults) '(scad-font-lock-keywords))
  (set (make-local-variable 'indent-line-function) 'scad-indent-line)
                                        ;(set (make-local-variable 'imenu-generic-expression) scad-imenu-generic-expression)
                                        ;(set (make-local-variable 'outline-regexp) scad-outline-regexp)
  ;; set comment styles for scad mode
  (set (make-local-variable 'comment-start) "//")
  (set (make-local-variable 'comment-end) "")
  (set (make-local-variable 'block-comment-start) "/*")
  (set (make-local-variable 'block-comment-end) "*/"))


;; From: http://stackoverflow.com/questions/14520073/add-words-for-dynamic-expansion-to-emacs-mode
(defun scad-prime-dabbrev ()
  "Makes a hidden scad-mode buffer containing all the scad keywords, so dabbrev expansion just works."
  (unless (get-buffer " *scad words*")
    (with-current-buffer (get-buffer-create " *scad words*")
      (scad-mode)
      (insert "module function use include")  ; Explicitly add these -- they're not in the below vars
      (insert (mapconcat 'identity (append scad-keywords scad-functions scad-modules) " ")))))

(add-hook 'scad-mode-hook 'scad-prime-dabbrev)

;;; Indentation, based on http://www.emacswiki.org/emacs/download/actionscript-mode-haas-7.0.el

(defun scad-indent-line ()
  "Indent current line of SCAD code."
  (interactive)
  (let ((savep (> (current-column) (current-indentation)))
        (indent (max (scad-calculate-indentation) 0)))
    (if savep
        (save-excursion (indent-line-to indent))
      (indent-line-to indent))))

(defun scad-calculate-indentation ()
  "Return the column to which the current line should be indented."
  (save-excursion
    (scad-maybe-skip-leading-close-delim)
    (let ((pos (point)))
      (beginning-of-line)
      (if (not (search-backward-regexp "[^\n\t\r ]" 1 0))
          0
        (progn
          (scad-maybe-skip-leading-close-delim)
          (+ (current-indentation) (* standard-indent (scad-count-scope-depth (point) pos))))))))

(defun scad-maybe-skip-leading-close-delim ()
  (beginning-of-line)
  (forward-to-indentation 0)
  (if (looking-at "\\s)")
      (forward-char)
    (beginning-of-line)))

(defun scad-face-at-point (pos)
  "Return face descriptor for char at point."
  (plist-get (text-properties-at pos) 'face))

(defun scad-count-scope-depth (rstart rend)
  "Return difference between open and close scope delimeters."
  (save-excursion
    (goto-char rstart)
    (let ((open-count 0)
          (close-count 0)
          opoint)
      (while (and (< (point) rend)
                  (progn (setq opoint (point))
                         (re-search-forward "\\s)\\|\\s(" rend t)))
        (if (= opoint (point))
            (forward-char 1)
          (cond
           ;; Don't count if in string or comment.
           ((scad-face-at-point (- (point) 1)))
           ((looking-back "\\s)")
            (setq close-count (+ close-count 1)))
           ((looking-back "\\s(")
            (setq open-count (+ open-count 1)))
           )))
      (- open-count close-count))))

(defun scad-open-current-buffer ()
  (interactive)
  (call-process scad-command nil 0 nil (buffer-file-name)))

(defun scad-output-stl ()
  (interactive)
  (async-shell-command (concat  scad-command " -o " (buffer-file-name) ".stl "
                              (buffer-file-name))))

;; Skeleton for easy editing
;; 3D
(define-skeleton scad-sphere
  "Insert sphere."
  "Sphere:"
  "sphere:(" str ");")

(define-skeleton scad-cube
  "Insert cube."
  "Cube:"
  "cube:(" str ");")

(define-skeleton scad-cylinder
  "Insert cylinder."
  "Cylinder:"
  "cylinder(" str ");")

(define-skeleton scad-polyhedron
  "Insert polyhedron."
  "Polyhedron:"
  "polyhedron(" str ");")

;; 2D

(define-skeleton scad-circle
  "Insert square."
  "Square:"
  "square(" str ");")

(define-skeleton scad-square
  "Insert square ."
  "Square:"
  "square(" str ");")

(define-skeleton scad-polygon
  "Insert polygon."
  "Polygon:"
  "Polygon(" str ");")

;; Transformations

(define-skeleton scad-translate
  "Insert translate."
  "translate:"
  "translate(" str "){"_"}")

(define-skeleton scad-rotate
  "Insert rotate."
  "rotate:"
  "rotate(" str "){"_"}")

(define-skeleton scad-scale
  "Insert scale."
  "Scale:"
  "scale(" str "){"_"}")

(define-skeleton scad-resize
  "Insert resize."
  "Resize:"
  "resize(" str "){"_"}")

(define-skeleton scad-mirror
  "Insert mirror."
  "Mirror:"
  "mirror(" str "){"_"}")

(define-skeleton scad-multmatrix
  "Insert multmatrix."
  "Multmatrix:"
  "multmatrix:(" str "){"_"}")

(define-skeleton scad-color
  "Insert color."
  "Color:"
  "color(" str "){"_"}")

(define-skeleton scad-hull
  "Insert hull."
  "Hull:"
  "hull(" str "){"_"}")

(define-skeleton scad-minkowski
  "Insert minkowski."
  "Minkowski:"
  "minkowski(){"_"}")

;; Boolean

(define-skeleton scad-union
  "Insert union."
  "Union:"
  "union(){}")

(define-skeleton scad-difference
  "Insert difference."
  "Difference:"
  "difference(){"_"}")

(define-skeleton scad-intersection
  "Insert intersection."
  "Intersection:"
  "intersection(){"_"}")

;; Syntax

(define-skeleton scad-module
  "Insert module."
  "Module:"
  "module " str "("_"){}")

(define-skeleton scad-function
  "Insert function."
  "Function:"
  "function " str "("_"){}")

(define-skeleton scad-include
  "Insert include."
  "Include:"
  "include <" str ".scad>")

(define-skeleton scad-use
  "Insert use."
  "Use:"
  "use <" str ".scad>")

;; Other

(define-skeleton scad-render
  "Insert render."
  "Render:"
  "render(){"_"}")


(define-skeleton scad-translate
  "Insert translate."
  "translate:"
  "translate(" str "){"_"}")

(define-skeleton scad-rotate
  "Insert rotate."
  "rotate:"
  "rotate(" str "){"_"}")

(define-skeleton scad-scale
  "Insert scale."
  "Scale:"
  "scale(" str "){"_"}")

(define-skeleton scad-resize
  "Insert resize."
  "Resize:"
  "resize(" str "){"_"}")

(define-skeleton scad-mirror
  "Insert mirror."
  "Mirror:"
  "mirror(" str "){"_"}")

(define-skeleton scad-multmatrix
  "Insert multmatrix."
  "Multmatrix:"
  "multmatrix:(" str "){"_"}")

(define-skeleton scad-color
  "Insert color."
  "Color:"
  "color(" str "){"_"}")

(define-skeleton scad-hull
  "Insert hull."
  "Hull:"
  "hull(" str "){"_"}")

(define-skeleton scad-minkowski
  "Insert minkowski."
  "Minkowski:"
  "minkowski(){"_"}")

;; Boolean

(define-skeleton scad-union
  "Insert union."
  "Union:"
  "union(){}")

(define-skeleton scad-difference
  "Insert difference."
  "Difference:"
  "difference(){"_"}")

(define-skeleton scad-intersection
  "Insert intersection."
  "Intersection:"
  "intersection(){"_"}")

;; Syntax

(define-skeleton scad-module
  "Insert module."
  "Module:"
  "module " str "("_"){}")

(define-skeleton scad-function
  "Insert function."
  "Function:"
  "function " str "("_"){}")

(define-skeleton scad-include
  "Insert include."
  "Include:"
  "include <" str ".scad>")

(define-skeleton scad-use
  "Insert use."
  "Use:"
  "use <" str ".scad>")

;; Other

(define-skeleton scad-render
  "Insert render."
  "Render:"
  "render(){"_"}")

(define-skeleton scad-for
  "Insert for."
  "For:"
  "for  (i=" str ")" "{" _ "}")
  

;; (define-skeleton scad-
;;   "Insert ."
;;   ":"
;;   "(" str ");")


(provide 'scad)
;;; scad-mode.el ends here

Enjoy.

Etiquetas/Tags: emacs, openscad


Viseiras de proteção: COVID19
impressas em 3D + acetato

2020/04/06-15:15:31

Um grupo de voluntários 3dmask PT começou a 3D imprimir viseiras par proteção para profissionais de saúde. Se precisar de uma envie-me um email para tiago.charters.azevedo@gmail.com ou contacte-me pelo twitter @charterazevedo. Consigo fazer entregas na zona de Lisboa.

O modelo usado está disponível para download.

Consigo imprimir cerca de 10 viseiras por dia. Para além da viseira impressa são necessários um elástico de escritório e um acetato A4 que deve ser substituído depois de algumas horas de utilização.

ATENÇÂO:

Instruções para furação do acetato

Dobrar levemente o acetato ao meio e marcar 8cm a partir da dobra.

Colocar a marca no centro do agrafador e furar.

Colocar o acetato na viseira: é necessário algum jeito para o colocar. Começar pelos suportes interiores e usar a elasticidade da armação para colocar o acetato.

Bem hajam!

Ref.:

Etiquetas/Tags: covid19, 3dprint, maker, mutual aid


Viseiras de proteção: COVID19
impressas em 3D + acetato

2020/03/24-18:19:21

Um grupo de voluntários 3dmask PT criou este modelo 3D para a impressão de uma viseira de proteção para profissionais de saúde. Se precisar de uma envie-me um email para tiago.charters.azevedo@gmail.com ou contacte-me pelo twitter @charterazevedo. Consigo fazer entregas na zona de Lisboa.

Consigo imprimir cerca de 6 viseiras por dia. Para além da viseira impressa são necessários um elástico de escritório e um acetato A4 que deve ser substituído depois de algumas horas de utilização.

ATENÇÂO: A viseira deve ser desinfetada regularmente com água e sabão e álcool. É feita em PETG e suporta temperaturas até 100 graus Celsius sem se deformar consideravelmente.

Instruções para furação do acetato

Dobrar levemente o acetato ao meio e marcar 7cm a partir da dobra.

Colocar a marca no centro do agrafador e furar.

Colocar o acetato na viseira: é necessário algum jeito para o colocar. Começar pelo suporte exterior e usar a elasticidade da armação para colocar o acetato. É necessária alguma força.

Bem hajam!

Etiquetas/Tags: covid19, 3dprint, maker, mutual aid


Aprops do COVID19

2020/03/11-17:44:09

Bacillus dendroides e a equação logística

O modelo logístico assume que o crescimento inicial de uma população com latex2png equation indivíduos aumenta exponencialmente com taxa de crescimento constante e à medida que latex2png equation aproxima-se do limite máximo e a taxa de crescimento latex2png equation diminui ando origem a uma curva tipo-S.

Os mecanismos que causam este abrandamento dependem da caracterização da população, ou do sistema a ser modelado, mas estudos empíricos mostram que este comportamento está presente em processos de crescimento e difusão, onde existe um sistema de feedback associado e.g. restrições ao uso de alimento, espaço físico, hospedeiros no caso de propagação viral, etc. Assim o modelo logístico é um modelo genérico que modela sistemas com mecanismos conhecidos mas também com propriedades escondidas.

O caso clássico é do crescimento da bactéria Bacillus dendroides1. A figura seguinte mostra os sucessivos estágios de desenvolvimento da bactéria Bacillus dendroides num período de 6 horas numa solução de agar-agar. Neste caso usa-se a área ocupada pelo crescimento como medida do número de B. dendroides em instantes sucessivos (latex2png equation).

É possível modelar o crescimento de latex2png equation indivíduos de uma determinada população através de uma equação diferencial, equação logística, com a forma latex2png equation

A solução da equação anterior com condição inicial latex2png equation (latex2png equation) é dada por

latex2png equation

O valor latex2png equation atinge metade do valor máximo latex2png equation no instante

latex2png equation

Outra forma de escrever a solução da equação e que é mais útil para estimar os parâmetros relevantes é3:

latex2png equation

1. R. Pearl, ‘‘The Growth of Population’’ Quart. Rev. Biol. 2, 532–548, (1927)

2. H. G. Thornton, On the development of a standardized agar medium for counting soil bacteria Ann. Appl. Biol., 9:241-274, (1922)

3. C. Mar-Molinero, Tractors in Spain: A Logistic Analysis, The Journal of the Operational Research Society, Vol. 31, No. 2, pp. 141-152 (1980)

Etiquetas/Tags:


Sequência de Kolakoski
Notas sobre a sequência de Kolakoski

2019/12/17-20:07:54

A sucessão de Kolakoski1 é definida por:

Um algoritmo simples é o seguinte (em 2 está a versão em GNU/Octave):

a=[1 2 2]
  i=3:n
    j=1:a(i)
      a=[a 1+mod(i-1,2)]

o que dá

 1  2 2  1 1  2  1  2 2  1  2 2  1 1  2
 -  ---  ---  -  -  ---  -  ---  ---  - (...)  
 1   2    2   1  1   2   1   2    2   1   

O algoritmo anterior está definido de uma forma imperativa e tem uma tradução para LISP com forma

(defun kolakoski. (n)
  "Kolakoski sequence."
  (let ((a '(1 2 2)))
    (do ((i 2 (+ i 1)))
        ((= i n))
      (do ((j 1 (+ j 1)))
          ((= j (+ 1 (car (nthcdr i a)))))
        (setq a (concatenate 'list a (list (+ 1 (mod i 2)))))))
    a))

Vejamos então como construir uma forma funcional para gerar a sequência. A ideia é obter o valor de m (ver figura acima) definido como o mínimo, fixado um n, de todas as somas maiores ou iguais a n o valor do n-ésimo termo da sucessão é então dado por

((lambda (x)  (/ (+ 3 (expt -1 x)) 2)) 'm)

. Antes de construirmos essa função precisamos de algumas funções auxiliares

(defun sum (x)
  "Sum of elements of X."
  (cond (x
         (+ (car x) (sum (cdr x))))
        (t 0)))

(defun lin-seq (n)
  "Retuns (1 2 3 ... n)."
  (cond ((= n 1)
         (list 1))
        (t
         (append (lin-seq (- n 1)) (list n)))))

(defun nest (op xo n)
  "Applies OP to XO N times."
  (cond ((= n 1)
        xo)
        (t (nest op (funcall op xo) (- n 1)))))

(defun partial-sum (lst)
  "Partial sums of LST."
  (reverse (maplist #'sum (reverse lst))))

Vejamos então como funciona a função find-m definida por

(defun find-m (lst n)
  (+ 1 (length  
        (mapcan #'(lambda (y) (and y (list y)))
                (mapcar 
                 #'(lambda (x) (<= x n)) (partial-sum lst))))))
É composta de duas partes: dada uma lista lst, a primeira, verifica se a condição <=n x é t ou nil, por exemplo, dada uma lista (1 2 3 4) com somas parciais (1 3 6 10) a aplicação da condição (< x 3)=, onde x é o valor de cada entrada da lista, dá
> (mapcar #'(lambda (x) (<= x 3)) (partial-sum '(1 2 3 4)))

(t t nil nil)
A segunda parte da função remove as entradas nil através de
> (mapcan #'(lambda (y) (and y (list y))) '(t t nil nil))

(t t)
e, logo, o valor de m é o comprimento desta última lista mais um.

De seguida verifica-se se está tudo bem calculando o valor dos sucessivos m

> (mapcar #'(lambda (x) (find-m (kolakoski. 20) x)) 
                '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20))

(1 2 2 3 3 4 5 6 6 7 8 8 9 9 10 11 11 12 12 13 14)
e desfaz-se a transformação de modo a obter a sequência original
> (kolakoski. 20)

(1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2 1 1 2 1 2 2 1 1 2)
através de
> (mapcar #'(lambda (x)  (/ (+ 3 (expt -1 x)) 2))
        (mapcar #'(lambda (x) (find-m (kolakoski. 20) x)) 
                '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)))

(1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2)

A construção da sequência de Kolakoski vem então definida por

(defun kolakoski (seq)
  (append seq (list (/ (+ 3 (expt -1
                        (find-m seq  (length seq) ))) 2))))
Exemplificando
(kolakoski '(1 2 2))
e
> (nest 'kolakoski '(1 2 2) 20)

(1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2 1)

1. The American Mathematical Monthly, Vol. 72, No. 6 (Jun. - Jul., 1965), pp. 673-67

2.

function retval = kolakoski (n)
  retval=[1 2 2];
  for i=3:n
    for j=1:retval(i)
      retval=[retval 1+mod((i-1),2)];
    endfor;
  endfor;
endfunction;

3. O número de termos não está correcto, a sequência final tem 22 termos e não 20, isto resolve-se com a indexação correcta de cada termo (índice que indexa as entradas de cada lista começa em 0).

Etiquetas/Tags: Kolakoski, Lisp, matemática, self-generating, GNU/Octave


Palavras chave/keywords: página pessoal, blog

Criado/Created: NaN

Última actualização/Last updated: 03-03-2021 [10:25]


Voltar à página inicial.


GNU/Emacs Creative Commons License

(c) Tiago Charters de Azevedo