Efficient Variables

[DonatasAzaravicius]

I am reading Efficient Variables post by Kenny Ramage.

And in post he says creating many variables in list is not efficient. But I debate  what is more efficient:

1) To create many variables.

2) To search list multiple times for variables.

I have this code

(defun ListEntity (data / layer color linetype lineweight linescale space) 
  (setq data       (if data data (list nil))
        layer      (nth 0 data) ; Layer name (string)
        color      (nth 1 data) ; Color code
        linetype   (nth 2 data) ; Linetype
        lineweight (nth 3 data) ; Lineweight: by block -2
        linescale  (nth 4 data) ; Linetype scale (optional)
        space      (nth 5 data) ; 0 = Model space, 1 = Paper space (optional)
        paper      (if (eq 0 space) "Model" (nth 6 data)) ; Paper space tab name
  )
  (list 
    '(100 . "AcDbEntity")
    (if space (cons 67 space) '(67 . 0))
    (if paper (cons 410 paper) '(410 . "Model"))
    (if layer (cons 8 layer) '(8 . "0"))
    (if linetype (cons 6 linetype) '(6 . "BYLAYER"))
    (if color (cons 62 color) '(62 . 256))
    (if lineweight (cons 370 lineweight) '(370 . -1))
    (if linescale (cons 48 linescale) '(48 . 1.0))
  )
)

I am getting parameters in list data, because I don't know if all variables will be in list or not. Maybe data itself will be just nil. 

First I check if data is nil. If it is I just create list with one nil so next code in setq would work. Retrive data to diffirent variables. They can also be nil.

After it, from line 13, I check if variable is nil or not. If it is not nil I add associative list with it, if it is nil, I just add default associative list.

So, I create 7 variables for data. I could write line 13 like this:

(if (nth 5 data) (cons 67 (nth 5 data)) '(67 . 0))

But will this be more efficient? To get data from list two times? Would here be any meaning with current compiuters power?

[diagodose2009]

You can increase the power -of variabiles, after you grow the speed of write/read variables.
In other programs languages , they use array[0..255] of integer ; these variabiles are very -fast-of-speed.
I believe using type of LIST , you decrease speed too much of speed.
Exists multiples questions>

a) How to blocked type of variabiles with one type ?
Eg1. (setint xcoo 10); If you use (setq xcoo 10.0) then , after the VLIDe.dll then will crash
(setstr sircd "Daca vrem sa rezistam in vremurile ce vor urma, trebuie sa ne marturisim credinta")
b1) How to defined the fast array of integers?

   How to defined the fast array of doubles?
b) How to redim the fast array of integer/doubles?

d)Exists other method to store values? (Eg2.  You store the values inside WinReg or RegEdit.exe)

  but here problem is the speed,  need control memory too much!

[Kent1Cooper · Accepted solution]

---

@DonatasAzaravicius wrote:

.... from line 13, I check if variable is nil or not. If it is not nil I add associative list with it, if it is nil, I just add default associative list.

So, I create 7 variables for data. I could write line 13 like this:

(if (nth 5 data) (cons 67 (nth 5 data)) '(67 . 0))

But will this be more efficient? To get data from list two times? ....

---

If I understand correctly, I think using (cond) instead of (if) would let you skip those variables, pull the information [if it is there] only once, and do this:

(defun ListEntity (data)
  (if (not data) (setq data (list nil))) 
  (list 
    '(100 . "AcDbEntity")
    (cons 67 (cond ((nth 5 data)) (0)))
    (cons 410 (cond ((nth 6 data)) ("Model")))
    (cons 8 (cond ((nth 0 data)) ("0")))
    (cons 6 (cond ((nth 2 data)) ("BYLAYER")))
    (cons 62 (cond ((nth 1 data)) (256)))
    (cons 370 (cond ((nth 3 data)) (-1)))
    (cons 48 (cond ((nth 4 data)) (1.0)))
  )
)

[john.uhden]

@Kent1Cooper ,

I think you just provided an example of how not to create variables at all.  I think it was you who taught me that it is faster to pass values from one operation to the next without having to save and recall a variable, though I still tend to do things the old-fashioned way because assigning a variable helps me remember its origin.

Mapcar is a great example of computing and passing values without ever naming them.  I also think that localizing variables saves memory and time.

BTW, instead of

  (if (not data) (setq data (list nil))) 
  (list 

 couldn't you have used...

(if data
  (list
  ...
)

[DonatasAzaravicius]

I think I would need to use this

(if data
  (list
  ...
  )
  (list
  ...
  )
)

 if I wan't to use your version. Because function needs to return default dxf codes if data is nil. So, it will need to have second list with all defaults and use Kent1Cooper code for first list. So, Kent1Cooper code should be shorter.

[DonatasAzaravicius]

---

@john.uhden wrote:

though I still tend to do things the old-fashioned way because assigning a variable helps me remember its origin.

---

I have same problem. Wanted to use ListAcDbEntity function and had problems remembering order of data in list.

Got idea to use association list for data. So, I have change funtion to this

(defun ListAcDbEntity (data) 
  (list 
    '(100 . "AcDbEntity")
    (cons 67 (cond ((cdr (assoc 'Space data))) (0)))
    (cons 410 (cond ((cdr (assoc 'PaperSpace data))) ("Model")))
    (cons 8 (cond ((cdr (assoc 'Layer data))) ("0")))
    (cons 6 (cond ((cdr (assoc 'Linetype data))) ("BYLAYER")))
    (cons 62 (cond ((cdr (assoc 'Color data))) (256)))
    (cons 370 (cond ((cdr (assoc 'Lineweight data))) (-1)))
    (cons 48 (cond ((cdr (assoc 'Linescale data))) (1.0)))
  )
)

Now I see meaning of every dxf from code. I also can call function and not care about order of data.

(ListAcDbEntity '((Layer . "My Layer") (Color . 5)))

Because this is helper function to create other lists, I can use one list for data.

(defun ListAcDbEntity (data) 
  (list 
    '(100 . "AcDbEntity")
    (cons 67 (cond ((cdr (assoc 'Space data))) (0)))
    (cons 410 (cond ((cdr (assoc 'PaperSpace data))) ("Model")))
    (cons 8 (cond ((cdr (assoc 'Layer data))) ("0")))
    (cons 6 (cond ((cdr (assoc 'Linetype data))) ("BYLAYER")))
    (cons 62 (cond ((cdr (assoc 'Color data))) (256)))
    (cons 370 (cond ((cdr (assoc 'Lineweight data))) (-1)))
    (cons 48 (cond ((cdr (assoc 'Linescale data))) (1.0)))
  )
)

(defun ListAcDbCircle (data) 
  (list 
    '(100 . "AcDbCircle")
    (cons 39 (cond ((cdr (assoc 'Thickness data))) (0.0)))
    (cons 10 (cond ((cdr (assoc 'Coords data))) ('(0.0 0.0 0.0))))
    (cons 40 (cond ((cdr (assoc 'Radius data))) (1.0)))
    (cons 210 (cond ((cdr (assoc 'Extrusion data))) ('(0.0 0.0 1.0))))
  )
)

(defun ListCircle (data) 
  (append 
    '((0 . "CIRCLE"))
    (ListAcDbEntity data)
    (ListAcDbCircle data)
  )
)

And to use it

(entmake (ListCircle '((Layer . "Circle") (Radius . 3.5) (Color . 1))))
; or
(entmake (ListCircle nil))

[Kent1Cooper]

The 'data' variable needs to exist as a list, even one with only one item in it which is nil.  If 'data' itself is nil, the (nth) functions return errors.

[john.uhden]

(if (and (listp data)(vl-some '(lambda (x)(not (not x))) data))

[ronjonp]

---

@DonatasAzaravicius wrote:

I am reading Efficient Variables post by Kenny Ramage.

And in post he says creating many variables in list is not efficient. But I debate  what is more efficient:

1) To create many variables.

2) To search list multiple times for variables.

---

Lisp is "list processing" not variable processing. Food for thought 😎