Решение 1:
Для 32-битных: Запустите «mysql.exe» из: C: \ Program Files \ MySQL \ MySQL Server 5.6 \ bin
Для 64-разрядных: Запустите «MySQLInstanceConfig.exe» из: C: \ Program Files \ MySQL \ MySQL Server 5.6 \ bin
Решение 2:
Ошибка (2002) Не удается подключиться к ... обычно означает, что в системе не работает сервер MySQL или вы используете неверное имя файла сокета Unix или номер порта TCP / IP при попытке подключиться к серверу. Вам также следует убедиться, что используемый вами порт TCP / IP не был заблокирован брандмауэром или службой блокировки портов.
Ошибка (2003) «Не удается подключиться к серверу MySQL на сервере» (10061) означает, что в сетевом соединении отказано. Вы должны убедиться, что сервер MySQL работает, на нем включены сетевые подключения и что указанный вами сетевой порт настроен на сервере.
Источник: http://dev.mysql.com/doc/refman/5.6/en/starting-server.html Посетите его для получения дополнительной информации.
Для чего нужен второй аргумент f
? На мой взгляд, обе эти альтернативы более читабельны и существенно не влияют на производительность ...
...
let g y = f y && y `mod` x > 0 in
x : mkPrimes g xs
...
import Control.Arrow -- instance Monad (-> r)
import Control.Monad -- liftM2
(.&&.) = liftM2 (&&)
...
let g y = y `mod` x > 0 in
x : mkPrimes (f .&&. g) xs
...
В любом случае, вернемся к вопросу. Иногда использование функций в качестве структур данных является лучшим представлением для определенной задачи, а иногда - нет. «Лучшие» с точки зрения простоты кодирования и «лучшие» с точки зрения производительности - не всегда одно и то же. Техника «функций как структур данных» важна для компиляции среды выполнения , но, как предупреждает эта страница,
компиляция среды выполнения иногда может принести вам значительный выигрыш в эффективности, но часто может принести вам почти ничего за счет ваш повышенный стресс и снижение производительности.
В вашем случае это ' Вероятно, что накладные расходы на построение каждого f :: Integer -> ... -> Bool
значительно выше, чем накладные расходы на построение каждого ps :: [Integer]
, с небольшим или никакой разницы при вызове f ... x
против all ... ps
.
Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов мод
! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2
).
import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
where
mkPrimes n m = case (M.null m, M.findMin m) of
(False, (n', skips)) | n == n' ->
mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
_ -> n : mkPrimes (succ n) (addSkip n m n)
addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
addSkips = foldl' . addSkip
В действии (с использованием небольшого синтаксиса JSON),
mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...
карта отслеживает будущие кратные, не используя ничего, кроме сложения.
Bool значительно выше, чем накладные расходы на построение каждого ps :: [Integer]
, с небольшой разницей или без разницы при вызове f ... x
против all. .. ps
.
Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod
! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2
).
import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
where
mkPrimes n m = case (M.null m, M.findMin m) of
(False, (n', skips)) | n == n' ->
mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
_ -> n : mkPrimes (succ n) (addSkip n m n)
addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
addSkips = foldl' . addSkip
В действии (с использованием небольшого синтаксиса JSON),
mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...
карта отслеживает будущие кратные, не используя ничего, кроме сложения.
Bool значительно выше, чем накладные расходы на построение каждого ps :: [Integer]
, с небольшой разницей или без разницы при вызове f ... x
против all. .. ps
.
Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod
! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2
).
import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
where
mkPrimes n m = case (M.null m, M.findMin m) of
(False, (n', skips)) | n == n' ->
mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
_ -> n : mkPrimes (succ n) (addSkip n m n)
addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
addSkips = foldl' . addSkip
В действии (с использованием небольшого синтаксиса JSON),
mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...
карта отслеживает будущие кратные, не используя ничего, кроме сложения.
ps . Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod
! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2
).
import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
where
mkPrimes n m = case (M.null m, M.findMin m) of
(False, (n', skips)) | n == n' ->
mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
_ -> n : mkPrimes (succ n) (addSkip n m n)
addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
addSkips = foldl' . addSkip
В действии (с использованием небольшого синтаксиса JSON),
mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...
карта отслеживает будущие кратные, не используя ничего, кроме сложения.
ps . Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod
! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2
).
import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
where
mkPrimes n m = case (M.null m, M.findMin m) of
(False, (n', skips)) | n == n' ->
mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
_ -> n : mkPrimes (succ n) (addSkip n m n)
addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
addSkips = foldl' . addSkip
В действии (с использованием небольшого синтаксиса JSON),
mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...
карта отслеживает будущие кратные, не используя ничего, кроме сложения.
Обратите внимание, что primes3
можно сделать более эффективным, изменив ps ++ [x]
на (x: ps)
. Бегущий (++)
линейен по длине своего левого аргумента, но постоянен по длине правого аргумента.