GPG Key ID:
C1980A470C3EE5B1
10 changed files with 944 additions and 44 deletions
@ -0,0 +1,72 @@
|
||||
import 'dart:async'; |
||||
|
||||
import 'package:flutter/foundation.dart'; |
||||
import 'package:flutter/material.dart'; |
||||
import 'package:flutter_hooks/flutter_hooks.dart'; |
||||
import 'package:logic_circuits_simulator/utils/logic_expressions.dart'; |
||||
import 'package:logic_circuits_simulator/utils/logic_operators.dart'; |
||||
|
||||
class LogicExpressionField extends HookWidget { |
||||
final ValueListenable<List<String>> inputsListener; |
||||
final String outputName; |
||||
final String? initialText; |
||||
final void Function(String input, LogicExpression expression)? onChanged; |
||||
final void Function()? onInputError; |
||||
|
||||
const LogicExpressionField({required this.inputsListener, required this.outputName, this.initialText, this.onChanged, this.onInputError, super.key}); |
||||
|
||||
@override |
||||
Widget build(BuildContext context) { |
||||
final inputs = useValueListenable(inputsListener); |
||||
final controller = useTextEditingController(text: initialText); |
||||
final errorText = useState<String?>(null); |
||||
useValueListenable(controller); |
||||
|
||||
final onChg = useMemoized(() => (String newValue) { |
||||
final trimmed = newValue.trim(); |
||||
|
||||
try { |
||||
if (trimmed.isEmpty) { |
||||
onChanged?.call('', LogicExpression(operator: FalseLogicOperator(), arguments: [])); |
||||
} |
||||
else { |
||||
final newLogicExpression = LogicExpression.parse(trimmed); |
||||
|
||||
// Check if unknown inputs are used |
||||
final newInputs = newLogicExpression.inputs; |
||||
final unknownInputs = newInputs.where((input) => !inputs.contains(input)).toList(); |
||||
if (unknownInputs.isNotEmpty) { |
||||
throw Exception('Unknown inputs found: ${unknownInputs.join(", ")}'); |
||||
} |
||||
|
||||
onChanged?.call(trimmed, newLogicExpression); |
||||
} |
||||
errorText.value = null; |
||||
} catch (e) { |
||||
errorText.value = e.toString(); |
||||
onInputError?.call(); |
||||
} |
||||
}, [inputs, errorText]); |
||||
useEffect( |
||||
() { |
||||
if (controller.text.isNotEmpty) { |
||||
scheduleMicrotask(() { |
||||
onChg(controller.text); |
||||
}); |
||||
} |
||||
return null; |
||||
}, |
||||
[inputs], |
||||
); |
||||
|
||||
return TextField( |
||||
controller: controller, |
||||
onChanged: onChg, |
||||
decoration: InputDecoration( |
||||
border: const OutlineInputBorder(), |
||||
labelText: 'Logic Experssion for $outputName', |
||||
errorText: errorText.value, |
||||
), |
||||
); |
||||
} |
||||
} |
||||
@ -0,0 +1,286 @@
|
||||
import 'dart:math'; |
||||
|
||||
import 'package:freezed_annotation/freezed_annotation.dart'; |
||||
import 'package:logic_circuits_simulator/utils/iterable_extension.dart'; |
||||
import 'package:logic_circuits_simulator/utils/logic_operators.dart'; |
||||
|
||||
part 'logic_expressions.freezed.dart'; |
||||
|
||||
@freezed |
||||
class LogicExpression with _$LogicExpression { |
||||
const LogicExpression._(); |
||||
|
||||
const factory LogicExpression({ |
||||
required LogicOperator operator, |
||||
required List<dynamic> arguments, |
||||
}) = _LogicExpression; |
||||
|
||||
factory LogicExpression.ofZeroOp(ZeroOpLogicOperator operator) => LogicExpression(operator: operator, arguments: []); |
||||
|
||||
static dynamic _classify(String token) { |
||||
final operators = [ |
||||
FalseLogicOperator(), |
||||
TrueLogicOperator(), |
||||
NotLogicOperator(), |
||||
AndLogicOperator(), |
||||
OrLogicOperator(), |
||||
XorLogicOperator(), |
||||
NandLogicOperator(), |
||||
NorLogicOperator(), |
||||
XnorLogicOperator(), |
||||
]; |
||||
|
||||
for (final op in operators) { |
||||
if (op.representations.contains(token)) { |
||||
return op; |
||||
} |
||||
} |
||||
|
||||
final inputStart = RegExp('^[A-Za-z]'); |
||||
if (inputStart.hasMatch(token)) { |
||||
return token; |
||||
} |
||||
|
||||
throw Exception('Unknown operator: $token'); |
||||
} |
||||
|
||||
static List<dynamic> _tokenize(String input) { |
||||
final space = ' '.codeUnits[0]; |
||||
final openedParen = '('.codeUnits[0]; |
||||
final closedParen = ')'.codeUnits[0]; |
||||
final transitionToOperator = RegExp('[^A-Za-z0-9]'); |
||||
final transitionToInput = RegExp('[A-Za-z]'); |
||||
|
||||
List<dynamic> result = []; |
||||
final buffer = StringBuffer(); |
||||
bool operator = false; |
||||
int parenDepth = 0; |
||||
|
||||
for (final rune in input.runes) { |
||||
if (rune == openedParen) { |
||||
if (parenDepth == 0 && buffer.isNotEmpty) { |
||||
result.add(_classify(buffer.toString())); |
||||
buffer.clear(); |
||||
} |
||||
else if (parenDepth > 0) { |
||||
buffer.writeCharCode(rune); |
||||
} |
||||
parenDepth++; |
||||
continue; |
||||
} |
||||
else if (rune == closedParen) { |
||||
parenDepth--; |
||||
if (parenDepth == 0) { |
||||
result.add(_tokenize(buffer.toString())); |
||||
buffer.clear(); |
||||
} |
||||
else if (parenDepth < 0) { |
||||
throw Exception('Unmached parenthesis: too many closed parenthesis'); |
||||
} |
||||
else { |
||||
buffer.writeCharCode(rune); |
||||
} |
||||
continue; |
||||
} |
||||
else if (parenDepth > 0) { |
||||
// While inside paren, just add stuff to the buffer to be further |
||||
// processed recursively and put inside of a list. |
||||
// ~(~(A&(A+B))+B& ~A) |
||||
// │ │ └───┘│ │ |
||||
// │ └───────┘ │ |
||||
// └────────────────┘ |
||||
buffer.writeCharCode(rune); |
||||
continue; |
||||
} |
||||
else if (rune == space) { |
||||
if (buffer.isNotEmpty) { |
||||
result.add(_classify(buffer.toString())); |
||||
buffer.clear(); |
||||
} |
||||
} |
||||
else { |
||||
if (buffer.isNotEmpty) { |
||||
// Check if switching from operator to input. |
||||
// This allows an expression such as A&B to be valid. |
||||
// Switching happens when in the middle of a token |
||||
// and changing from [A-Za-z0-9] to [^A-Za-z0-9] |
||||
// or from [^A-Za-z] to [A-Za-z]. |
||||
// Inputs can't start with digits. |
||||
if (!operator && transitionToOperator.hasMatch(String.fromCharCode(rune))) { |
||||
result.add(_classify(buffer.toString())); |
||||
buffer.clear(); |
||||
} |
||||
else if (operator && transitionToInput.hasMatch(String.fromCharCode(rune))) { |
||||
result.add(_classify(buffer.toString())); |
||||
buffer.clear(); |
||||
} |
||||
} |
||||
if (buffer.isEmpty) { |
||||
operator = !transitionToInput.hasMatch(String.fromCharCode(rune)); |
||||
} |
||||
buffer.writeCharCode(rune); |
||||
} |
||||
} |
||||
if (parenDepth != 0) { |
||||
throw Exception('Unmached parenthesis: too many open parenthesis'); |
||||
} |
||||
if (buffer.isNotEmpty) { |
||||
result.add(_classify(buffer.toString())); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
factory LogicExpression.parse(String input) { |
||||
final tokens = _tokenize(input); |
||||
|
||||
final result = LogicExpression._parse(tokens); |
||||
if (result is String) { |
||||
return LogicExpression( |
||||
operator: OrLogicOperator(), |
||||
arguments: [ |
||||
result, |
||||
LogicExpression.ofZeroOp(FalseLogicOperator()), |
||||
], |
||||
); |
||||
} |
||||
else { |
||||
return result; |
||||
} |
||||
} |
||||
|
||||
static dynamic _parse(dynamic input) { |
||||
if (input is List) { |
||||
final tokens = input; |
||||
|
||||
final orderedOpGroups = [ |
||||
[OrLogicOperator(), NorLogicOperator()], |
||||
[XorLogicOperator(), XnorLogicOperator()], |
||||
[AndLogicOperator(), NandLogicOperator()], |
||||
[NotLogicOperator()], |
||||
[FalseLogicOperator(), TrueLogicOperator()], |
||||
]; |
||||
|
||||
for (final ops in orderedOpGroups) { |
||||
for (var i = tokens.length - 1; i >= 0; i--) { |
||||
if (ops.contains(tokens[i])) { |
||||
if (tokens[i] is ZeroOpLogicOperator) { |
||||
// ZeroOp operator should be alone |
||||
if (tokens.length != 1) { |
||||
throw Exception('ZeroOp operator should be alone'); |
||||
} |
||||
return LogicExpression.ofZeroOp(tokens[i]); |
||||
} |
||||
else if (tokens[i] is OneOpLogicOperator) { |
||||
// OneOp operator should appear prefix only |
||||
// So index should be 0 |
||||
if (i != 0) { |
||||
throw Exception('OneOp operator should be prefix'); |
||||
} |
||||
// It should only be possible to get here if there is only one argument |
||||
// follows. The only other case is someone writing: |
||||
// ~ A B |
||||
// which would result in [NotLogicOperator, 'A', 'B']. |
||||
// Such syntax is ambiguous and should not be allowed: |
||||
// (~ A) & B -or- ~ (A & B) ? |
||||
// This is the disadvantage of linear, left-to-right notation (as opposed |
||||
// to the notation with a bar above the NOT-ed expression). |
||||
if (tokens.length > 2) { |
||||
throw Exception('Ambiguous expression: ${tokens[i]} followed by multiple tokens (${tokens.skip(1).toList()})'); |
||||
} |
||||
else if (tokens.length == 1) { |
||||
throw Exception('Unfinished expression'); |
||||
} |
||||
return LogicExpression( |
||||
operator: tokens[0], |
||||
arguments: [_parse(tokens[1])], |
||||
); |
||||
} |
||||
else if (tokens[i] is TwoOpLogicOperator) { |
||||
return LogicExpression( |
||||
operator: tokens[i], |
||||
arguments: [ |
||||
_parse(tokens.getRange(0, i).toList()), |
||||
_parse(tokens.getRange(i + 1, tokens.length).toList()), |
||||
], |
||||
); |
||||
} |
||||
else { |
||||
throw Exception('Matched with operator that somehow isn\'t Zero/One/TwoOp'); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// No operators were found. This means the only tokens are props. |
||||
// If there is only one prop, return it alone: |
||||
// A => [A] => A |
||||
// If there are multiple props, apply AND: |
||||
// A B C => [A, B, C] => A & B & C => (A & B) & C |
||||
// Keep in mind the second case is only possible if the props are separated by spaces, |
||||
// as the nature of prop names allowing multiple characters only allows multiple props |
||||
// to appear one after the other if separated by spaces. |
||||
if (tokens.length == 1) { |
||||
return tokens[0]; |
||||
} |
||||
else if (tokens.isEmpty) { |
||||
// This happens in unfinished expressions: |
||||
// A ^ ! => XOR(A, NOT(?)) |
||||
// A ^ => XOR(A, ?) |
||||
throw Exception('Unfinished expression'); |
||||
} |
||||
else { |
||||
final and = AndLogicOperator(); |
||||
return _parse(tokens.expand((token) => [and, token]).skip(1).toList()); |
||||
} |
||||
} |
||||
else if (input is String) { |
||||
// Prop, just return. |
||||
// Happens in such cases: |
||||
// B & ~ A => & [B, ~ [A]] |
||||
// ^ ^ |
||||
return input; |
||||
} |
||||
|
||||
} |
||||
|
||||
Set<String> get inputs { |
||||
Set<String> result = {}; |
||||
for (final arg in arguments) { |
||||
if (arg is String) { |
||||
result.add(arg); |
||||
} |
||||
else if (arg is LogicExpression) { |
||||
result.addAll(arg.inputs); |
||||
} |
||||
else { |
||||
throw Exception('Unknown argument type found: ${arg.runtimeType}'); |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
bool evaluate(Map<String, bool> inputs) { |
||||
return operator.apply( |
||||
arguments |
||||
.map( |
||||
// If the argument is a logical expression, evaluate recursively |
||||
// else it must be an input name, so replace based on supplied mapping. |
||||
(e) => e is LogicExpression ? e.evaluate(inputs) : inputs[e]! |
||||
) |
||||
.toList(), |
||||
); |
||||
} |
||||
|
||||
List<String> computeTruthTable(List<String> inputs) { |
||||
final ttRows = pow(2, inputs.length) as int; |
||||
return List.generate( |
||||
ttRows, |
||||
(index) => evaluate( |
||||
{ |
||||
for (var element in inputs.reversed.indexedMap((index, input) => [index, input])) |
||||
element[1] as String : (index & (pow(2, element[0] as int) as int)) != 0 |
||||
}, |
||||
) ? '1' : '0', |
||||
); |
||||
} |
||||
} |
||||
@ -0,0 +1,159 @@
|
||||
// coverage:ignore-file |
||||
// GENERATED CODE - DO NOT MODIFY BY HAND |
||||
// ignore_for_file: type=lint |
||||
// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target |
||||
|
||||
part of 'logic_expressions.dart'; |
||||
|
||||
// ************************************************************************** |
||||
// FreezedGenerator |
||||
// ************************************************************************** |
||||
|
||||
T _$identity<T>(T value) => value; |
||||
|
||||
final _privateConstructorUsedError = UnsupportedError( |
||||
'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#custom-getters-and-methods'); |
||||
|
||||
/// @nodoc |
||||
mixin _$LogicExpression { |
||||
LogicOperator get operator => throw _privateConstructorUsedError; |
||||
List<dynamic> get arguments => throw _privateConstructorUsedError; |
||||
|
||||
@JsonKey(ignore: true) |
||||
$LogicExpressionCopyWith<LogicExpression> get copyWith => |
||||
throw _privateConstructorUsedError; |
||||
} |
||||
|
||||
/// @nodoc |
||||
abstract class $LogicExpressionCopyWith<$Res> { |
||||
factory $LogicExpressionCopyWith( |
||||
LogicExpression value, $Res Function(LogicExpression) then) = |
||||
_$LogicExpressionCopyWithImpl<$Res>; |
||||
$Res call({LogicOperator operator, List<dynamic> arguments}); |
||||
} |
||||
|
||||
/// @nodoc |
||||
class _$LogicExpressionCopyWithImpl<$Res> |
||||
implements $LogicExpressionCopyWith<$Res> { |
||||
_$LogicExpressionCopyWithImpl(this._value, this._then); |
||||
|
||||
final LogicExpression _value; |
||||
// ignore: unused_field |
||||
final $Res Function(LogicExpression) _then; |
||||
|
||||
@override |
||||
$Res call({ |
||||
Object? operator = freezed, |
||||
Object? arguments = freezed, |
||||
}) { |
||||
return _then(_value.copyWith( |
||||
operator: operator == freezed |
||||
? _value.operator |
||||
: operator // ignore: cast_nullable_to_non_nullable |
||||
as LogicOperator, |
||||
arguments: arguments == freezed |
||||
? _value.arguments |
||||
: arguments // ignore: cast_nullable_to_non_nullable |
||||
as List<dynamic>, |
||||
)); |
||||
} |
||||
} |
||||
|
||||
/// @nodoc |
||||
abstract class _$$_LogicExpressionCopyWith<$Res> |
||||
implements $LogicExpressionCopyWith<$Res> { |
||||
factory _$$_LogicExpressionCopyWith( |
||||
_$_LogicExpression value, $Res Function(_$_LogicExpression) then) = |
||||
__$$_LogicExpressionCopyWithImpl<$Res>; |
||||
@override |
||||
$Res call({LogicOperator operator, List<dynamic> arguments}); |
||||
} |
||||
|
||||
/// @nodoc |
||||
class __$$_LogicExpressionCopyWithImpl<$Res> |
||||
extends _$LogicExpressionCopyWithImpl<$Res> |
||||
implements _$$_LogicExpressionCopyWith<$Res> { |
||||
__$$_LogicExpressionCopyWithImpl( |
||||
_$_LogicExpression _value, $Res Function(_$_LogicExpression) _then) |
||||
: super(_value, (v) => _then(v as _$_LogicExpression)); |
||||
|
||||
@override |
||||
_$_LogicExpression get _value => super._value as _$_LogicExpression; |
||||
|
||||
@override |
||||
$Res call({ |
||||
Object? operator = freezed, |
||||
Object? arguments = freezed, |
||||
}) { |
||||
return _then(_$_LogicExpression( |
||||
operator: operator == freezed |
||||
? _value.operator |
||||
: operator // ignore: cast_nullable_to_non_nullable |
||||
as LogicOperator, |
||||
arguments: arguments == freezed |
||||
? _value._arguments |
||||
: arguments // ignore: cast_nullable_to_non_nullable |
||||
as List<dynamic>, |
||||
)); |
||||
} |
||||
} |
||||
|
||||
/// @nodoc |
||||
|
||||
class _$_LogicExpression extends _LogicExpression { |
||||
const _$_LogicExpression( |
||||
{required this.operator, required final List<dynamic> arguments}) |
||||
: _arguments = arguments, |
||||
super._(); |
||||
|
||||
@override |
||||
final LogicOperator operator; |
||||
final List<dynamic> _arguments; |
||||
@override |
||||
List<dynamic> get arguments { |
||||
// ignore: implicit_dynamic_type |
||||
return EqualUnmodifiableListView(_arguments); |
||||
} |
||||
|
||||
@override |
||||
String toString() { |
||||
return 'LogicExpression(operator: $operator, arguments: $arguments)'; |
||||
} |
||||
|
||||
@override |
||||
bool operator ==(dynamic other) { |
||||
return identical(this, other) || |
||||
(other.runtimeType == runtimeType && |
||||
other is _$_LogicExpression && |
||||
const DeepCollectionEquality().equals(other.operator, operator) && |
||||
const DeepCollectionEquality() |
||||
.equals(other._arguments, _arguments)); |
||||
} |
||||
|
||||
@override |
||||
int get hashCode => Object.hash( |
||||
runtimeType, |
||||
const DeepCollectionEquality().hash(operator), |
||||
const DeepCollectionEquality().hash(_arguments)); |
||||
|
||||
@JsonKey(ignore: true) |
||||
@override |
||||
_$$_LogicExpressionCopyWith<_$_LogicExpression> get copyWith => |
||||
__$$_LogicExpressionCopyWithImpl<_$_LogicExpression>(this, _$identity); |
||||
} |
||||
|
||||
abstract class _LogicExpression extends LogicExpression { |
||||
const factory _LogicExpression( |
||||
{required final LogicOperator operator, |
||||
required final List<dynamic> arguments}) = _$_LogicExpression; |
||||
const _LogicExpression._() : super._(); |
||||
|
||||
@override |
||||
LogicOperator get operator => throw _privateConstructorUsedError; |
||||
@override |
||||
List<dynamic> get arguments => throw _privateConstructorUsedError; |
||||
@override |
||||
@JsonKey(ignore: true) |
||||
_$$_LogicExpressionCopyWith<_$_LogicExpression> get copyWith => |
||||
throw _privateConstructorUsedError; |
||||
} |
||||
@ -0,0 +1,138 @@
|
||||
abstract class LogicOperator { |
||||
bool apply(List<bool> inputs); |
||||
List<String> get representations; |
||||
String get defaultRepresentation => representations[0]; |
||||
bool fromRepresentation(String repr) => representations.contains(repr); |
||||
} |
||||
|
||||
abstract class ZeroOpLogicOperator extends LogicOperator {} |
||||
|
||||
class FalseLogicOperator extends ZeroOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => false; |
||||
|
||||
@override |
||||
List<String> get representations => ['0']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is FalseLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
class TrueLogicOperator extends ZeroOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => true; |
||||
|
||||
@override |
||||
List<String> get representations => ['1']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is TrueLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
abstract class OneOpLogicOperator extends LogicOperator {} |
||||
|
||||
class NotLogicOperator extends OneOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => !inputs[0]; |
||||
|
||||
@override |
||||
List<String> get representations => const ['~', '!', '¬']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is NotLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
abstract class TwoOpLogicOperator extends LogicOperator {} |
||||
|
||||
class AndLogicOperator extends TwoOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => inputs[0] && inputs[1]; |
||||
|
||||
@override |
||||
List<String> get representations => const ['&', '∧']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is AndLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
class OrLogicOperator extends TwoOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => inputs[0] || inputs[1]; |
||||
|
||||
@override |
||||
List<String> get representations => const ['|', '∨']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is OrLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
class XorLogicOperator extends TwoOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => inputs[0] != inputs[1]; |
||||
|
||||
@override |
||||
List<String> get representations => const ['^', '⊕', '⊻']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is XorLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
class NandLogicOperator extends TwoOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => !(inputs[0] && inputs[1]); |
||||
|
||||
@override |
||||
List<String> get representations => const ['~&', '!&', '¬&', '~∧', '!∧', '¬∧']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is NandLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
class NorLogicOperator extends TwoOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => !(inputs[0] || inputs[1]); |
||||
|
||||
@override |
||||
List<String> get representations => const ['~|', '!|', '¬|', '~∨', '!∨', '¬∨']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is NorLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
|
||||
class XnorLogicOperator extends TwoOpLogicOperator { |
||||
@override |
||||
bool apply(List<bool> inputs) => inputs[0] == inputs[1]; |
||||
|
||||
@override |
||||
List<String> get representations => const ['~^', '!^', '¬^', '~⊕', '!⊕', '¬⊕', '~⊻', '!⊻', '¬⊻']; |
||||
|
||||
@override |
||||
bool operator==(other) => other is XnorLogicOperator; |
||||
|
||||
@override |
||||
int get hashCode => defaultRepresentation.hashCode; |
||||
} |
||||
Loading…
Reference in new issue