[Red Nova]

Со школы не ладится у меня с программированием. Все предметы щелкал, а на экзамене по информатике (Visual foxpro) программку типа суммирования столбцов списал у соседа (это уже в университете).
Не смотря на эте намерен научится писать программы для Автокада на лиспе, скачал книгу Хювенена, несколько примеров создания программ, но после получасового “смотрения” таких книг мое мышление явно притормаживает.
Решил пойти другим путем.
Нашел самый короткий лисп из моей коллекции, и прошу программистов с этого форума пошагово объяснить какой символ что означает. Надеюсь на вашу помощь.

Код:

[Выделить все]

(defun c:make-blocks-explodeable (/ adoc)
  (vl-load-com)
  (vla-startundomark
    (setq adoc (vla-get-activedocument (vlax-get-acad-object)))
    ) ;_ end of vla-startundomark
  (vlax-for blk_def (vla-get-blocks adoc)
    (if (and (equal (vla-get-isxref blk_def) :vlax-false)
             (equal (vla-get-islayout blk_def) :vlax-false)
             ) ;_ end of and
      (vl-catch-all-apply '(lambda () (vla-put-explodable blk_def :vlax-true)))
      ) ;_ end of if
    ) ;_ end of vlax-for
  (vla-endundomark adoc)
  (princ)
  ) ;_ end of defun

_____________________________________________________________________________________________________________

Прошло много лет и топик теперь представляет из себя площадку для обучения азов программирования для многих начинающих.
Так что начинающие лиспогрызы приветствуются .

[gomer]

Сообщение от Disney там же совсем всё просто, или тебе рекурсии ни как покоя не дают?

Ой, вот именно не дают... Кажется, мой мозг отбился от рук... В последнее время одни только идеи... например dcl библиотека блоков с деревом по xml-файлу, наподобие того, что ты сделал здесь
я то надеялся обойтись одной простой рекурсивной функцией... но не тут-то было...

[Дима_]

Сообщение от gomer Хотелось бы увидеть решение от Димы_ ... ... ...

Друзья мои я сейчас занят "люто" (большой проект делаю) - заскавиваю на форум чтоб от писанины отдохнуть - где то рядом Дисней еще про прямоугольники спрашивали - будет время обязательно отпишусь - здесь "конечно" я бы сделал рекурсией в один проход

Код:

[Выделить все]

 (defun vagon (lst)
 ((lambda(f-rec) (f-rec 0 0 0 0 0 0 lst))
   (lambda (count maxlen maxlen-start tmp-max tmp-start current lst)
   (if lst
       (if (= (car lst) 1)
           (if (= maxlen tmp-max)
               (f-rec (1+ count) (1+ maxlen) tmp-start (1+ tmp-max)
                      (if (zerop tmp-start) current tmp-start)
                      (1+ current) (cdr lst))
               (f-rec (1+ count) maxlen maxlen-start (1+ tmp-max)
                      (if (zerop tmp-start) current tmp-start)
                      (1+ current) (cdr lst))) 
           (f-rec count maxlen maxlen-start 0 0 (1+ current) (cdr lst)))
       (strcat "Всего " (rtos count)
               " цистерн, наибольшая цепочка в " (rtos maxlen)
               " цистерн(ы), с началом c " (rtos maxlen-start) " вагона.")))))

чирканул "не глядя" - вроде работает. Всем удачи.

[Sleekka]

Дима_, скажи пожалуйста что почитать, чтобы научиться также использовать lambda как ты, без единого setq?

[Дима_]

Тут главное понять не как, а для чего. Про стили программироваия неплохо расписанно в "Структура и интерпритация компьютерных программ", ну а в целом - почитайте про функциональное программирование.

[Sleekka]

Просто я никогда в книгах по visualLisp не встречал как работает конструкция

Код:

[Выделить все]

 ((lambda

Для меня lambda это тест функция mapcar, а как интерпретируется

Код:

[Выделить все]

 ((lambda

- я ума не приложу.
Я бы разбивал список так.

Код:

[Выделить все]

 (defun C:vagoni (/)
(princ (setq sda '( 0 0 1 0 1 1 1 0 0 0 1 1 0 0 1 1 1 0 0 0 1 1 0 0 0 1 1 )))
(princ "\n")
(princ "\nЦистерн: ")
(princ (length (vl-remove-if (lambda (x) (eq x 1)) sda)))
(setq new_cist_cep_ (list))
(setq new_cist_Podcep_ (list))
(setq new_cist_Podcep_vag_ (list))
(foreach ent sda
(if (eq ent 0)
(progn
(setq new_cist_Podcep_ (cons ent new_cist_Podcep_))
(setq new_cist_cep_ (cons new_cist_Podcep_vag_ new_cist_cep_))
(setq new_cist_Podcep_vag_ (list))
)
(progn
(setq new_cist_Podcep_vag_ (cons ent new_cist_Podcep_vag_))
(setq new_cist_cep_ (cons new_cist_Podcep_ new_cist_cep_))
(setq new_cist_Podcep_ (list))
)
)
)
(setq new_cist_cep_ (cons new_cist_Podcep_vag_ new_cist_cep_))
(setq new_cist_cep_ (cons new_cist_Podcep_ new_cist_cep_))

(setq new_cist_cep_ (reverse new_cist_cep_))
(setq new_cist_cep_ (vl-remove-if (lambda (x) (eq x nil)) new_cist_cep_))
)

Это достаточно криво, хотелось бы понять и другой прием, но пока в лиспе не будет никаких улучшений с быстротой, то разбираться с этим действительно незачем.

[Дима_]

Лямбда - функция высшего порядка от произвольного числа аргументов возвращающая новую (пользовательскую) функцию - где первый аргумент - это список имен аргументов будующей функции, все остальные - тело функции. В отличие от большинства остальных функций - функция запускается "сразу" - до вычисления вложенных аргументов (т.н. специальная форма - так-же как и if, and, or,cond...). По сути defun и setq это обертка т.н. "синтетический сахар" от lambda (в defun добавляется параметр имени функции, в setq - область определения лямбды "расширяется" на все окружение).

но пока в лиспе не будет никаких улучшений с быстротой

- если в смысле autolisp, то боюсь что autodesk "положил" на него окончательно.

[Sleekka]

1) Спасибо за разъяснения - уже становится понятно, что это настоящий лисп, а то что я писал до этого, это обычный старый паскале-подобный код написанный на лиспе. Применять лисп как раз и нужно, через вот эти lambda т.к. сложные функциональные задачи проще и понятнее расписать через настоящий лисп, нежели пытаться превратить это все в циклы.
Автодеск то забил, но и у нас есть возможность забить на автодеск.
Интерпретатор в бриксе например работает ощутимо быстрее. Но это все равно не то чего хотелось бы.
То что автодеск забил, вообще никого не волнует, хочется вооружиться нормальными фраймворками, получать данные о примитивах АВТОКАДА (если вообще автокада, может быть ревитиа, инвентора и т.д.) через API, а уже с данными о примитивах работать на настоящем функциональном лиспе (я где то видел проект где народ пишет компилятор лиспа в MSIL - вот это сила) т.е. я хочу писать лисп-код для "умной" работы с данными для того чтобы получить конечный результат.
А вот получение введенных данных и вывод конечного результата, это удел C# .NET API, для того они и развивались долгие годы в бизнесс-приложениях и добились в этом отличных результатов. Существуют и обычные интерпретаторы под JAVA видимо скоро появятся и для C#, но я сомневаюсь что они будут сильно быстрее чем нынешний лисп в автокаде, а вот компилятор LISP - MSIL - это мне кажется будет серьезный рост производительности, а также кросплатформенность соответствующая самым современным требованиям к ПО.
Но саму идею о том что:
"Лисп-программист не разбивает алгоритм на отдельные элементарные шаги, не использует циклы, ветвления, присвоения значений переменным, а строит функцию, решающую поставленную задачу. При этом структура функции почти дословно соответствует математической формулировке решаемой задачи.
Подобная методология сейчас называется функциональным программированием. Лисп – первый функциональный язык программирования и, вероятно, первый язык, который явно приветствовал использование рекурсии."
ее нельзя убить, пока останутся умные люди на земле, она будет жить в веках.

Эта задачка с вагонами не особо сложна, но дает отличную возможность сравнить два стиля императивный и функциональный, попробую разобраться с твоим кодом (Дима_ ) и применять подобный подход, в своем проекте, надо же когда-нибудь учиться прекрасному.

[gomer]

Сообщение от Sleekka Эта задачка с вагонами не особо сложна, но дает отличную возможность сравнить два стиля императивный и функциональный

блин, а я все не могу докумекать как код из #1440 сделать рекурсией... видимо простой рекурсией точно не получится...

[TararykovDG]

Сообщение от gomer блин, а я все не могу докумекать как код из #1440 сделать рекурсией... видимо простой рекурсией точно не получится...

gomer, там (в #1440) кстати ошибка. В конце, вместо lst_out должно быть (append lst_out (list lst_current)), а то конец списка не возвращается. Это я от спешки не досмотрел. А вот и рекурсия, правда не очень-то изящно

Код:

[Выделить все]

 
_$ (setq lst (list 2 0 1 2 1 0 1 1 1 2 0 2 2 0 1 1 1 1 0 0 0 1 0 1 1 1 1 2 0))
(2 0 1 2 1 0 1 1 1 2 0 2 2 0 1 1 1 1 0 0 0 1 0 1 1 1 1 2 0)

((lambda(f-rec) (f-rec (cdr lst) (list (list (car lst)))))
  (lambda(lst_in lst_out)
    (if lst_in
      (if (= (car lst_in) (last (last lst_out)))
	(f-rec (cdr lst_in) (reverse (append (list (append (car (reverse lst_out)) (list (car lst_in)))) (cdr (reverse lst_out)))))
	(f-rec (cdr lst_in) (append lst_out (list (list (car lst_in)))))
	)
      lst_out
      )
    )
  )

((2) (0) (1) (2) (1) (0) (1 1 1) (2) (0) (2 2) (0) (1 1 1 1) (0 0 0) (1) (0) (1 1 1 1) (2) (0))
_$ 

[ShaggyDoc]

Но саму идею о том что: "Лисп-программист не разбивает алгоритм на отдельные элементарные шаги, не использует циклы, ветвления, присвоения значений переменным, а строит функцию, решающую поставленную задачу. При этом структура функции почти дословно соответствует математической формулировке решаемой задачи. Подобная методология сейчас называется функциональным программированием. Лисп – первый функциональный язык программирования и, вероятно, первый язык, который явно приветствовал использование рекурсии." ее нельзя убить, пока останутся умные люди на земле, она будет жить в веках.

Но LISP-программисты, которые "не разбивает алгоритм на отдельные элементарные шаги, не использует циклы, ветвления, присвоения значений переменным" - ради чистоты идеи, неспособны разрабатывать программы, необходимые пользователям. Реализовывать математические формулировки задач - да, могут. А если формулировка "не эдакая" - пусть её реализует быдло императивными стилями. Потому что это "неправильная задача".

...она будет жить в веках

Будет. Как идея. Как "город солнца" Кампанеллы. Как живет с 1952 года, когда появился LISP. Надежды, на него возлагавшиеся, не оправдались. Во многом именно благодаря усилиям "пуристов". А когда не зацикливаются на самой идее, которая "будет жить в веках", а используют любые наиболее подходящие средства - получают результаты.

Уж поверьте мне, я наверняка больше всех на форуме и программ и функций написал. И "лямбды" использую (когда надо), и переменные, и (ужас!) циклы и ветвления.

[Дима_]

Сообщение от ShaggyDoc Но LISP-программисты, которые "не разбивает алгоритм на отдельные элементарные шаги, не использует циклы, ветвления, присвоения значений переменным" - ради чистоты идеи, неспособны разрабатывать программы, необходимые пользователям.

При всем уважении Вы здесь загнули. Я буквально неделю назад "смалодушничал" и ввел в f# переменную, а потом замучился потоки синхронизировать - вовремя одумался и убрал ее от греха подальше. Посмотрите на 4 .Net - там и динамическую типизацию ввели, да и в общем все что добавили - корнями упирается в 52 год. Я не сомневаюсь что это действительно вопрос времени т.к. автоматическая оптимизация на порядок отличается в фунуциональных программах, а в рукопашную далеко не уедешь. На наш век конечно "дураков хватит", но ИХМО путь тупиковый.

[ShaggyDoc]

Дима_, а при чем тут f# и .Net?

Тут идеи "которые будут жить в веках" про Лисп-программистов. Причем в конкретной реализации - Автолисп (слабенький, конечно, диалект).

Вот бы вместо идей предъявить полезную прикладную программу (не этюд). Например, как чрезвычайно популярные PlTools или Прокат от Василия Кондрата. Они же ужасно, с точки зрения "вечной идеи" написаны, но нужны людям.

[gomer]

ShaggyDoc, а где Ваш "ответ Чемберлену" (тоже ведь рекурсия )
Вот пока мой... Вроде бы стало все на свои места... но мне все равно не нравится...

Код:

[Выделить все]

 (setq *train* '(4 5 0 0 0 1 0 1 1 2 1 0 0 0 1 1 0 0 1 1 1 0 0 0 6 3)
      *c*     1
      *v*     0
)
(defun train (lst / _train)
  (defun _train	(lst_in lst_out)
    (if	lst_in
      (_train
	(cdr lst_in)
	(if (eq (caar lst_in) (car (last lst_out)))
	  (reverse
	    (cons
	      (append (last lst_out) (car lst_in))
	      (cdr (reverse lst_out))
	    )
	  )
	  (append lst_out (list (car lst_in)))
	)
      )
      lst_out
    )
  )
  (_train (mapcar 'list lst) '())
)

(defun maxchain	(vlst vtype)
  (car
    (vl-sort
      (vl-remove-if-not
	'(lambda (x) (eq vtype (car x)))
	(train vlst)
      )
      '(lambda (x y) (< (length y) (length x)))
    )
  )
)

(defun maxlen (vlst vtype)
  (length (maxchain *train* *c*))
)

(defun maxpos (vlst vtype)
  (vl-position (maxchain vlst vtype) (train vlst))
)

(maxlen *train* *c*)
(maxpos *train* *c*)

Сообщение от ShaggyDoc Вот бы вместо идей предъявить полезную прикладную программу (не этюд). Например, как чрезвычайно популярные PlTools или Прокат от Василия Кондрата. Они же ужасно, с точки зрения "вечной идеи" написаны, но нужны людям.

Почему не может? Чем вам не прикладная задача про цистерны??? В своем алгоритме я выделил три действия - три функции. Если я правильно понимаю, то у всех в принципе алгоритм тот же - переливание "из пустого в порожнее", кроме Димы_ и Sleekka, которые используют прием hwd...
Вот вам еще: расставить вагоны по боксам для ремонта в зависимости от типа вагона... имеем два списка: состав и боксы...
Если в программе нет кнопачек то она не перестает быть программой по определению... важен именно алгоритм... а язык и способ реализации вторичны...
зы Насчет pltools не скажу, но 'прокат' потому и развивается "никак", что написан на "бейсике".

[ShaggyDoc]

Чем вам не прикладная задача про цистерны

А, ну если это "задача", то "тады ой". Это все учебные этюды, которые в учебники можно помещать.

'прокат' потому и развивается "никак", что написан на "бейсике"

Ну, так попробуй переписать по-своему. Хотя бы ради интереса. Вот это - обычная прикладная программа. Написанная намного сложнее, чем можно было. Вот на ней и можно потренироваться.

Боксы и вагоны - это наподобие "ханойских башен" - практически никому не интересны. А прокат - то, что всем надо. Да еще в 3D.

Никакого "абстракционизьма", сплошной "реализьм".

[Дима_]

Сообщение от TararykovDG А вот и рекурсия, правда не очень-то изящно

ИХМО накрутили Вы коллега здесь лишнего - простое правило - если алгоритм простой, то и рекурсия должна выглядеть просто (без надобности я стараюсь не использовать list и append внутри рекурсии - т.к. в итоге это только код усложняет):

Код:

[Выделить все]

 (defun test (lst)
 ((lambda (f-rec) (f-rec (cons (car lst) nil) (cdr lst)))
     (lambda (x lst)
       (if lst
           (if (equal (car x) (car lst))
               (f-rec (cons (car lst) x) (cdr lst))
               (cons x (f-rec (cons (car lst) nil) (cdr lst))))
           (cons x nil)))))

[TararykovDG]

Сообщение от Дима_ ИХМО накрутили Вы коллега здесь лишнего - простое правило - если алгоритм простой, то и рекурсия должна выглядеть просто (без надобности я стараюсь не использовать list и append внутри рекурсии - т.к. в итоге это только код усложняет):

Дима_, я не спорю, просто так как у Вас у меня пока не получается .

[gomer]

Сообщение от ShaggyDoc Ну, так попробуй переписать по-своему. Хотя бы ради интереса. Вот это - обычная прикладная программа. Написанная намного сложнее, чем можно было. Вот на ней и можно потренироваться. Боксы и вагоны - это наподобие "ханойских башен" - практически никому не интересны. А прокат - то, что всем надо. Да еще в 3D. Никакого "абстракционизьма", сплошной "реализьм".

Хм, пробовал, но забил... когда стал разбираться... и на болты болт положил к сожалению... потому что ошибся где-то и не смог найти ошибку

Насчет башен согласен, а насчет не интересно - увы, хотя каждому свое: строителям - прокат, машиностроителям - болты, железнодорожникам - цистерны и вагоны

Дима_, это как раз то, что я хотел...

Код:

[Выделить все]

 (defun train (lst / _train)
  (defun _train (lst_out lst_in)
    (if lst_in
      (if (equal (car lst_out) (car lst_in))
        (_train (cons (car lst_in) lst_out) (cdr lst_in))
        (cons lst_out (_train (list (car lst_in)) (cdr lst_in)))
      )
      (list lst_out)
    )
  )
  (_train (list (car lst)) (cdr lst))
)

воть

/ Перенесено из http://forum.dwg.ru/showthread.php?t=7411 / kpblc /
Почему лисп рисует объект по введённым параметрам на запросы командной строки для предпоследних введённых параметров?

[gomer]

прошло 5 лет... рамка все еще актуальна?

Нет
Другое уже.

Код:

[Выделить все]

 (defun c:razvertka ()
  (setq	H1	(getreal "\n Введите высоту элемента конструкции H1=")
	K1	(getreal
		  "\n Введите размер между внутренними поверхностями граней нижнего основания (диаметр для конуса) K1="
		) ;_ конец getreal
	k2	(getreal
		  "\n Введите размер между внутренними поверхностями граней верхнего основания (диаметр для конуса) k2="
		) ;_ конец getreal
	Udugokr	(getreal
		  "\n Введите в градусах значение угла дуги подлежащей развёртыванию Udugokr="
		) ;_ конец getreal
	ngran	(getint
		  "\n Введите количество граней элемента конструкции ngran="
		) ;_ конец getint
	rp	(getreal "\n Введите радиус инструмента (пуансона) rp=")
	tm	(getreal "\n Введите толщину изгибаемого материала tm= ")
	x	(getreal "\n Введите значение коэффициента изгиба x= ")
	BT	(getpoint
		  "\n Введите координаты базовой точки: [можно мышкой] "
		) ;_ конец getpoint
  ) ;_ конец setq
  (if (= 0 ngran)
    ((setq alfaradian (/ (* pi Udugokr) 180)
	   KK1	      (+ K1 (* 2 (* tm x)))
	   kk2	      (+ k2 (* 2 (* tm x)))
	   Ldug	      (* (* 0.5 kk2) alfaradian)
	   betta1     (atan (/ (- KK1 kk2) (* 2 H1)))
	   r2	      (/ (* 0.5 kk2) (sin betta1))
	   R1	      (/ (* 0.5 KK1) (sin betta1))
	   betta2     (* 0.5 (/ Ldug r2))
	   BT1	      (polar BT (- (* 1.5 pi) betta2) r2)
	   BT2	      (polar BT (* 1.5 pi) r2)
	   BT3	      (polar BT (+ (* 1.5 pi) betta2) r2)
	   BT4	      (polar BT (- (* 1.5 pi) betta2) R1)
	   BT5	      (polar BT (* 1.5 pi) R1)
	   BT6	      (polar BT (+ (* 1.5 pi) betta2) R1)
     ) ;_ конец setq
      (command "_.ARC" BT1 BT2 BT3 "_.ARC" BT4 BT5 BT6)
      (command "_.line" BT1 BT4 "")
      (command "_.line" BT3 BT6 "")
      (command "_.zoom" "_E")
    ) ;_ конец command
    ((setq Y1		    (/ 360 (* 2 ngran))
	   Y1rad	    (/ (* Y1 pi) 180)
	   KK1		    (+ K1 (* tm x))
	   kk2		    (+ k2 (* tm x))
	   Lgran1	    (* 2 (* KK1 (sin Y1rad)))
	   lgran2	    (* 2 (* kk2 (sin Y1rad)))
	   Rgib		    (+ rp (* tm x))
	   Y2rad	    (* 2 Y1rad)
	   Lduggib	    (* Rgib Y2rad)
	   L1kraingran	    (+ Lgran1 (* 0.5 Lduggib))
	   l2kraingran	    (+ lgran2 (* 0.5 Lduggib))
	   L1osngran	    (+ Lgran1 Lduggib)
	   l2osngran	    (+ lgran2 Lduggib)
	   betta3	    (atan (/ (- KK1 kk2) (* 2 H1)))
	   Visotagrani	    (/ H1 (cos betta3))
	   Raznicakraingran (/ (- L1kraingran l2kraingran) 2)
	   Lrebra	    (sqrt (+ (* Raznicakraingran Raznicakraingran)
				     (* Visotagrani Visotagrani)
				  ) ;_ конец +
			    ) ;_ конец sqrt
	   mu		    (atan (/ Raznicakraingran Visotagrani))
	   P1		    (/ (- (* 0.5 KK1) Rgib) (cos Y1rad))
	   p2		    (/ (- (* 0.5 kk2) Rgib) (cos Y1rad))
	   D1		    (* 2 (+ P1 Rgib))
	   d2		    (* 2 (+ p2 Rgib))
	   betta4	    (atan (/ (- D1 d2) (* 2 H1)))
	   Sh		    (/ (* 0.5 d2) (sin betta4))
	   BT7		    (polar BT (* 1.5 pi) Sh)
	   BT8		    (polar BT7 (+ (* 2 pi) mu) l2kraingran)
	   BT9		    (polar BT7 (* 1.5 pi) Lrebra)
	   BT10		    (polar BT9 (+ (* 2 pi) mu) L1kraingran)
	   BT11		    (polar BT8 (+ (* 2 pi) (* 2 mu)) l2osngran)
	   BT12		    (polar BT10 (+ (* 2 pi) (* 2 mu)) L1osngran)
     ) ;_ конец setq
      (command "_.pline" BT7 "_w" 1 1 BT8 BT10 BT9 BT7 "")
      (command "_.pline" BT8 "_w" 1 1 BT11 BT12 BT10 BT8 "")
      (command "_.zoom" "_E")
    ) ;_ конец if
  ) ;_ конец defun  
) ;_ конец defun

gomer

Особо не критикуйте.Пишу код как могу-с книжкой в руках.

В общем проблема в следующем:загружаю активное окно редактора лиспа,перехожу в автокад,из буфера в командую строку вставляю razvertka,дальше по просьбам ком.строки-первый результат нулевой (пусто).В ком.строке какаято ошибка.Повторный ввод-отрисовывает развёртку по ппервым данным.

p.s.Код недоделанный.